Changeset 2115 in josm for trunk/src/org


Ignore:
Timestamp:
2009-09-13T19:30:36+02:00 (15 years ago)
Author:
Gubaer
Message:

new: reading open changesets from the server
new: reading user info from the server
new: any open changeset can be used when uploading
new: generic dialog for closing changesets
fixed #3427: JOSM can't keep many changesets open at once
fixed #3408: Allow continuing opened changeset even after restarting JOSM
fixed #3476: Default selection in upload dialog should be different for unclosed changesets. (Upload dialog now looks different)

Location:
trunk/src/org/openstreetmap/josm
Files:
10 added
16 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/actions/CloseChangesetAction.java

    r2113 r2115  
    11// License: GPL. For details, see LICENSE file.
    22package org.openstreetmap.josm.actions;
     3
     4import static org.openstreetmap.josm.tools.I18n.tr;
    35
    46import java.awt.event.ActionEvent;
    57import java.awt.event.KeyEvent;
    68import java.io.IOException;
     9import java.util.Collection;
     10import java.util.List;
    711
    812import javax.swing.JOptionPane;
     13import javax.swing.SwingUtilities;
    914
    1015import org.openstreetmap.josm.Main;
     16import org.openstreetmap.josm.data.osm.Changeset;
     17import org.openstreetmap.josm.data.osm.UserInfo;
    1118import org.openstreetmap.josm.gui.ExceptionDialogUtil;
    1219import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    13 import org.openstreetmap.josm.io.ChangesetProcessingType;
    14 import org.openstreetmap.josm.io.OsmApi;
     20import org.openstreetmap.josm.gui.io.CloseChangesetDialog;
     21import org.openstreetmap.josm.gui.io.CloseChangesetTask;
     22import org.openstreetmap.josm.io.ChangesetQuery;
     23import org.openstreetmap.josm.io.OsmServerChangesetReader;
     24import org.openstreetmap.josm.io.OsmServerUserInfoReader;
    1525import org.openstreetmap.josm.io.OsmTransferException;
    1626import org.openstreetmap.josm.tools.Shortcut;
    1727import org.xml.sax.SAXException;
    1828
    19 import static org.openstreetmap.josm.tools.I18n.tr;
     29public class CloseChangesetAction extends JosmAction{
    2030
    21 public class StopChangesetAction extends JosmAction{
    22 
    23     public StopChangesetAction() {
    24         super(tr("Close current changeset"),
     31    public CloseChangesetAction() {
     32        super(tr("Close open changesets"),
    2533                "closechangeset",
    26                 tr("Close the current changeset ..."),
     34                tr("Closes open changesets"),
    2735                Shortcut.registerShortcut(
    2836                        "system:closechangeset",
    29                         tr("File: {0}", tr("Close the current changeset ...")),
     37                        tr("File: {0}", tr("Closes open changesets")),
    3038                        KeyEvent.VK_Q,
    3139                        Shortcut.GROUP_HOTKEY + Shortcut.GROUPS_ALT2
    … …  
    3644    }
    3745    public void actionPerformed(ActionEvent e) {
    38         if (OsmApi.getOsmApi().getCurrentChangeset() == null) {
     46        Main.worker.submit(new DownloadOpenChangesetsTask());
     47    }
     48
     49
     50    protected void onPostDownloadOpenChangesets(DownloadOpenChangesetsTask task) {
     51        if (task.isCancelled() || task.getLastException() != null) return;
     52
     53        List<Changeset> openChangesets = task.getChangesets();
     54        if (openChangesets.isEmpty()) {
    3955            JOptionPane.showMessageDialog(
    4056                    Main.parent,
    41                     tr("There is currently no changeset open."),
    42                     tr("No open changeset"),
     57                    tr("There are no open changesets"),
     58                    tr("No open changesets"),
    4359                    JOptionPane.INFORMATION_MESSAGE
    4460            );
    4561            return;
    4662        }
    47         Main.worker.submit(new StopChangesetActionTask());
     63
     64        CloseChangesetDialog dialog = new CloseChangesetDialog();
     65        dialog.setChangesets(openChangesets);
     66        dialog.setVisible(true);
     67        if (dialog.isCanceled())
     68            return;
     69
     70        Collection<Changeset> changesetsToClose = dialog.getSelectedChangesets();
     71        CloseChangesetTask closeChangesetTask = new CloseChangesetTask(changesetsToClose);
     72        Main.worker.submit(closeChangesetTask);
    4873    }
    4974
    50     @Override
    51     protected void updateEnabledState() {
    52         setEnabled(Main.map != null && OsmApi.getOsmApi().getCurrentChangeset() != null);
    53     }
    5475
    55     static class StopChangesetActionTask extends PleaseWaitRunnable {
     76    private class DownloadOpenChangesetsTask extends PleaseWaitRunnable {
     77
    5678        private boolean cancelled;
     79        private OsmServerChangesetReader reader;
     80        private List<Changeset> changesets;
    5781        private Exception lastException;
     82        private UserInfo userInfo;
    5883
    59         public StopChangesetActionTask() {
    60             super(tr("Closing changeset"), false /* don't ignore exceptions */);
     84        /**
     85         *
     86         * @param model provides the user id of the current user and accepts the changesets
     87         * after download
     88         */
     89        public DownloadOpenChangesetsTask() {
     90            super(tr("Downloading open changesets ...", false /* don't ignore exceptions */));
    6191        }
     92
    6293        @Override
    6394        protected void cancel() {
    6495            this.cancelled = true;
    65             OsmApi.getOsmApi().cancel();
    66 
     96            reader.cancel();
    6797        }
    6898
    6999        @Override
    70100        protected void finish() {
    71             if (cancelled)
    72                 return;
    73             if (lastException != null) {
    74                 ExceptionDialogUtil.explainException(lastException);
    75             }
     101            SwingUtilities.invokeLater(
     102                    new Runnable() {
     103                        public void run() {
     104                            if (lastException != null) {
     105                                ExceptionDialogUtil.explainException(lastException);
     106                            }
     107                            onPostDownloadOpenChangesets(DownloadOpenChangesetsTask.this);
     108                        }
     109                    }
     110            );
     111        }
     112
     113        /**
     114         * Fetch the user info from the server. This is necessary if we don't know
     115         * the users id yet
     116         *
     117         * @return the user info
     118         * @throws OsmTransferException thrown in case of any communication exception
     119         */
     120        protected UserInfo fetchUserInfo() throws OsmTransferException {
     121            OsmServerUserInfoReader reader = new OsmServerUserInfoReader();
     122            return reader.fetchUserInfo(getProgressMonitor().createSubTaskMonitor(1, false));
    76123        }
    77124
    … …  
    79126        protected void realRun() throws SAXException, IOException, OsmTransferException {
    80127            try {
    81                 OsmApi.getOsmApi().stopChangeset(ChangesetProcessingType.USE_EXISTING_AND_CLOSE, getProgressMonitor().createSubTaskMonitor(1, false));
     128                userInfo = fetchUserInfo();
     129                if (cancelled)
     130                    return;
     131                reader = new OsmServerChangesetReader();
     132                ChangesetQuery query = new ChangesetQuery().forUser(userInfo.getId()).beingOpen();
     133                changesets = reader.queryChangesets(
     134                        query,
     135                        getProgressMonitor().createSubTaskMonitor(1, false /* not internal */)
     136                );
    82137            } catch(Exception e) {
    83138                if (cancelled)
    … …  
    86141            }
    87142        }
     143
     144        public boolean isCancelled() {
     145            return cancelled;
     146        }
     147
     148        public List<Changeset> getChangesets() {
     149            return changesets;
     150        }
     151
     152        public Exception getLastException() {
     153            return lastException;
     154        }
    88155    }
    89156}

  • trunk/src/org/openstreetmap/josm/actions/UploadAction.java

    r2096 r2115  
    2828import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2929import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    30 import org.openstreetmap.josm.io.ChangesetProcessingType;
    3130import org.openstreetmap.josm.io.OsmApi;
    3231import org.openstreetmap.josm.io.OsmApiException;
    … …  
    176175                        Main.map.mapView.getEditLayer(),
    177176                        apiData.getPrimitives(),
    178                         UploadConfirmationHook.getUploadDialog().getChangeset(),
    179                         UploadConfirmationHook.getUploadDialog().getChangesetProcessingType()
     177                        UploadDialog.getUploadDialog().getChangeset(),
     178                        UploadDialog.getUploadDialog().isDoCloseAfterUpload()
    180179                )
    181180        );
    … …  
    244243        );
    245244        switch(ret) {
    246         case JOptionPane.CLOSED_OPTION: return;
    247         case JOptionPane.CANCEL_OPTION: return;
    248         case 0: synchronizePrimitive(primitiveType, id); break;
    249         case 1: synchronizeDataSet(); break;
    250         default:
    251             // should not happen
    252             throw new IllegalStateException(tr("unexpected return value. Got {0}", ret));
     245            case JOptionPane.CLOSED_OPTION: return;
     246            case JOptionPane.CANCEL_OPTION: return;
     247            case 0: synchronizePrimitive(primitiveType, id); break;
     248            case 1: synchronizeDataSet(); break;
     249            default:
     250                // should not happen
     251                throw new IllegalStateException(tr("unexpected return value. Got {0}", ret));
    253252        }
    254253    }
    … …  
    284283        );
    285284        switch(ret) {
    286         case JOptionPane.CLOSED_OPTION: return;
    287         case 1: return;
    288         case 0: synchronizeDataSet(); break;
    289         default:
    290             // should not happen
    291             throw new IllegalStateException(tr("unexpected return value. Got {0}", ret));
     285            case JOptionPane.CLOSED_OPTION: return;
     286            case 1: return;
     287            case 0: synchronizeDataSet(); break;
     288            default:
     289                // should not happen
     290                throw new IllegalStateException(tr("unexpected return value. Got {0}", ret));
    292291        }
    293292    }
    … …  
    457456
    458457    static public class UploadConfirmationHook implements UploadHook {
    459         static private UploadDialog uploadDialog;
    460 
    461         static public UploadDialog getUploadDialog() {
    462             if (uploadDialog == null) {
    463                 uploadDialog = new UploadDialog();
    464             }
    465             return uploadDialog;
    466         }
    467458
    468459        public boolean checkUpload(APIDataSet apiData) {
    469             final UploadDialog dialog = getUploadDialog();
     460            final UploadDialog dialog = UploadDialog.getUploadDialog();
    470461            dialog.setUploadedPrimitives(apiData.getPrimitivesToAdd(),apiData.getPrimitivesToUpdate(), apiData.getPrimitivesToDelete());
    471462            dialog.setVisible(true);
    … …  
    477468    }
    478469
    479     public UploadDiffTask createUploadTask(OsmDataLayer layer, Collection<OsmPrimitive> toUpload, Changeset changeset, ChangesetProcessingType changesetProcessingType) {
    480         return new UploadDiffTask(layer, toUpload, changeset, changesetProcessingType);
    481     }
    482 
     470    public UploadDiffTask createUploadTask(OsmDataLayer layer, Collection<OsmPrimitive> toUpload, Changeset changeset, boolean closeChangesetAfterUpload) {
     471        return new UploadDiffTask(layer, toUpload, changeset, closeChangesetAfterUpload);
     472    }
     473
     474    /**
     475     * The task for uploading a collection of primitives
     476     *
     477     */
    483478    public class UploadDiffTask extends  PleaseWaitRunnable {
    484479        private boolean uploadCancelled = false;
    … …  
    488483        private OsmDataLayer layer;
    489484        private Changeset changeset;
    490         private ChangesetProcessingType changesetProcessingType;
    491 
    492         private UploadDiffTask(OsmDataLayer layer, Collection <OsmPrimitive> toUpload, Changeset changeset, ChangesetProcessingType changesetProcessingType) {
     485        private boolean closeChangesetAfterUpload;
     486
     487        /**
     488         *
     489         * @param layer  the OSM data layer for which data is uploaded
     490         * @param toUpload the collection of primitives to upload
     491         * @param changeset the changeset to use for uploading
     492         * @param closeChangesetAfterUpload true, if the changeset is to be closed after uploading
     493         */
     494        private UploadDiffTask(OsmDataLayer layer, Collection <OsmPrimitive> toUpload, Changeset changeset, boolean closeChangesetAfterUpload) {
    493495            super(tr("Uploading data for layer ''{0}''", layer.getName()),false /* don't ignore exceptions */);
    494496            this.toUpload = toUpload;
    495497            this.layer = layer;
    496498            this.changeset = changeset;
    497             this.changesetProcessingType = changesetProcessingType == null ? ChangesetProcessingType.USE_NEW_AND_CLOSE : changesetProcessingType;
     499            this.closeChangesetAfterUpload = closeChangesetAfterUpload;
    498500        }
    499501
    … …  
    502504            try {
    503505                ProgressMonitor monitor = progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false);
    504                 writer.uploadOsm(layer.data.version, toUpload, changeset,changesetProcessingType, monitor);
     506                writer.uploadOsm(layer.data.version, toUpload, changeset,closeChangesetAfterUpload, monitor);
    505507            } catch (Exception sxe) {
    506508                if (uploadCancelled) {
    … …  
    525527                handleFailedUpload(lastException);
    526528            } else {
     529                // run post upload action on the layer
     530                //
    527531                layer.onPostUploadToServer();
     532                // refresh changeset dialog with the updated changeset
     533                //
     534                UploadDialog.getUploadDialog().setOrUpdateChangeset(changeset);
    528535            }
    529536        }

  • trunk/src/org/openstreetmap/josm/data/osm/Changeset.java

    r2081 r2115  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
    6 import javax.print.attribute.standard.MediaSize.Other;
    7 
     6import java.util.Collection;
     7import java.util.Date;
     8import java.util.HashMap;
     9import java.util.Map;
     10
     11import org.openstreetmap.josm.data.coor.LatLon;
    812import org.openstreetmap.josm.data.osm.visitor.Visitor;
    913
    … …  
    1317 *
    1418 */
    15 public final class Changeset extends OsmPrimitive {
     19public final class Changeset implements Tagged {
     20    /** the changeset id */
     21    private long id;
     22    /** the user who owns the changeset */
     23    private User user;
     24    /** date this changeset was created at */
     25    private Date createdAt;
     26    /** the date this changeset was closed at*/
     27    private Date closedAt;
     28    /** indicates whether this changeset is still open or not */
     29    private boolean open;
     30    /** the min. coordinates of the bounding box of this changeset */
     31    private LatLon min;
     32    /** the max. coordinates of the bounding box of this changeset */
     33    private LatLon max;
     34    /** the map of tags */
     35    private Map<String,String> tags;
     36    /** indicates whether this changeset is incomplete. For an
     37     * incomplete changeset we only know its id
     38     */
     39    private boolean incomplete;
     40
     41
    1642    /**
    17      * Time of last modification to this object. This is not set by JOSM but
    18      * read from the server and delivered back to the server unmodified.
     43     * Creates a new changeset with id 0.
    1944     */
    20     public String end_timestamp = null;
     45    public Changeset() {
     46        this.id = 0;
     47        this.tags = new HashMap<String, String>();
     48    }
    2149
    2250    /**
    23      * Time of first modification to this object. This is not set by JOSM but
    24      * read from the server and delivered back to the server unmodified.
     51     * Creates a changeset with id <code>id</code>. If id > 0, sets incomplete to true.
     52     *
     53     * @param id the id
    2554     */
    26     public String start_timestamp = null;
    27 
    28     public Changeset() {
    29         super(0);
    30     }
    31 
    3255    public Changeset(long id) {
    33         super(id);
    34     }
    35 
    36     public Changeset(Changeset clone){
    37         super(clone.getId());
    38         cloneFrom(clone);
    39     }
    40 
    41     @Override
     56        this.id = id;
     57        this.incomplete = id > 0;
     58        this.tags = new HashMap<String, String>();
     59    }
     60
     61    /**
     62     * Creates a clone of <code>other</code>
     63     *
     64     * @param other the other changeset. If null, creates a new changeset with id 0.
     65     */
     66    public Changeset(Changeset other) {
     67        if (other == null) {
     68            this.id = 0;
     69            this.tags = new HashMap<String, String>();
     70        } else if (other.isIncomplete()) {
     71            setId(other.getId());
     72            this.incomplete = true;
     73        } else {
     74            cloneFrom(other);
     75            this.incomplete = false;
     76        }
     77    }
     78
     79    public void cloneFrom(Changeset other) {
     80        setId(other.getId());
     81        setUser(other.getUser());
     82        setCreatedAt(other.getCreatedAt());
     83        setClosedAt(other.getClosedAt());
     84        setMin(other.getMin());
     85        setMax(other.getMax());
     86        setKeys(other.getKeys());
     87        setOpen(other.isOpen());
     88    }
     89
    4290    public void visit(Visitor v) {
    4391        v.visit(this);
    4492    }
    4593
    46     public int compareTo(OsmPrimitive other) {
    47         if (other instanceof Changeset) return Long.valueOf(getId()).compareTo(other.getId());
    48         return 1;
    49     }
    50 
    51     @Override
     94    public int compareTo(Changeset other) {
     95        return Long.valueOf(getId()).compareTo(other.getId());
     96    }
     97
    5298    public String getName() {
    5399        // no translation
    … …  
    55101    }
    56102
    57     @Override
    58103    public String getLocalName(){
    59104        return tr("Changeset {0}",getId());
    60105    }
    61106
    62     @Override
    63107    public String getDisplayName(NameFormatter formatter) {
    64108        return formatter.format(this);
    65109    }
    66110
    67 
    68     @Override public void cloneFrom(OsmPrimitive osm) {
    69         super.cloneFrom(osm);
     111    public long getId() {
     112        return id;
     113    }
     114
     115    public void setId(long id) {
     116        this.id = id;
     117    }
     118
     119    public User getUser() {
     120        return user;
     121    }
     122
     123    public void setUser(User user) {
     124        this.user = user;
     125    }
     126
     127    public Date getCreatedAt() {
     128        return createdAt;
     129    }
     130
     131    public void setCreatedAt(Date createdAt) {
     132        this.createdAt = createdAt;
     133    }
     134
     135    public Date getClosedAt() {
     136        return closedAt;
     137    }
     138
     139    public void setClosedAt(Date closedAt) {
     140        this.closedAt = closedAt;
     141    }
     142
     143    public boolean isOpen() {
     144        return open;
     145    }
     146
     147    public void setOpen(boolean open) {
     148        this.open = open;
     149    }
     150
     151    public LatLon getMin() {
     152        return min;
     153    }
     154
     155    public void setMin(LatLon min) {
     156        this.min = min;
     157    }
     158
     159    public LatLon getMax() {
     160        return max;
     161    }
     162
     163    public void setMax(LatLon max) {
     164        this.max = max;
     165    }
     166
     167    public Map<String, String> getKeys() {
     168        return tags;
     169    }
     170
     171    public void setKeys(Map<String, String> keys) {
     172        this.tags = keys;
     173    }
     174
     175    public boolean isIncomplete() {
     176        return incomplete;
     177    }
     178
     179    public void setIncomplete(boolean incomplete) {
     180        this.incomplete = incomplete;
     181    }
     182
     183    public void put(String key, String value) {
     184        this.tags.put(key, value);
     185    }
     186
     187    public String get(String key) {
     188        return this.tags.get(key);
     189    }
     190
     191    public void remove(String key) {
     192        this.tags.remove(key);
     193    }
     194
     195    public boolean hasEqualSemanticAttributes(Changeset other) {
     196        if (other == null)
     197            return false;
     198        if (closedAt == null) {
     199            if (other.closedAt != null)
     200                return false;
     201        } else if (!closedAt.equals(other.closedAt))
     202            return false;
     203        if (createdAt == null) {
     204            if (other.createdAt != null)
     205                return false;
     206        } else if (!createdAt.equals(other.createdAt))
     207            return false;
     208        if (id != other.id)
     209            return false;
     210        if (max == null) {
     211            if (other.max != null)
     212                return false;
     213        } else if (!max.equals(other.max))
     214            return false;
     215        if (min == null) {
     216            if (other.min != null)
     217                return false;
     218        } else if (!min.equals(other.min))
     219            return false;
     220        if (open != other.open)
     221            return false;
     222        if (tags == null) {
     223            if (other.tags != null)
     224                return false;
     225        } else if (!tags.equals(other.tags))
     226            return false;
     227        if (user == null) {
     228            if (other.user != null)
     229                return false;
     230        } else if (!user.equals(other.user))
     231            return false;
     232        return true;
     233    }
     234
     235    @Override
     236    public int hashCode() {
     237        final int prime = 31;
     238        int result = 1;
     239        result = prime * result + (int) (id ^ (id >>> 32));
     240        if (id > 0)
     241            return prime * result + getClass().hashCode();
     242        result = prime * result + ((closedAt == null) ? 0 : closedAt.hashCode());
     243        result = prime * result + ((createdAt == null) ? 0 : createdAt.hashCode());
     244        result = prime * result + ((max == null) ? 0 : max.hashCode());
     245        result = prime * result + ((min == null) ? 0 : min.hashCode());
     246        result = prime * result + (open ? 1231 : 1237);
     247        result = prime * result + ((tags == null) ? 0 : tags.hashCode());
     248        result = prime * result + ((user == null) ? 0 : user.hashCode());
     249        return result;
     250    }
     251
     252    @Override
     253    public boolean equals(Object obj) {
     254        if (this == obj)
     255            return true;
     256        if (obj == null)
     257            return false;
     258        if (getClass() != obj.getClass())
     259            return false;
     260        Changeset other = (Changeset) obj;
     261        if (this.id > 0 && other.id == this.id)
     262            return true;
     263        if (closedAt == null) {
     264            if (other.closedAt != null)
     265                return false;
     266        } else if (!closedAt.equals(other.closedAt))
     267            return false;
     268        if (createdAt == null) {
     269            if (other.createdAt != null)
     270                return false;
     271        } else if (!createdAt.equals(other.createdAt))
     272            return false;
     273        if (id != other.id)
     274            return false;
     275        if (max == null) {
     276            if (other.max != null)
     277                return false;
     278        } else if (!max.equals(other.max))
     279            return false;
     280        if (min == null) {
     281            if (other.min != null)
     282                return false;
     283        } else if (!min.equals(other.min))
     284            return false;
     285        if (open != other.open)
     286            return false;
     287        if (tags == null) {
     288            if (other.tags != null)
     289                return false;
     290        } else if (!tags.equals(other.tags))
     291            return false;
     292        if (user == null) {
     293            if (other.user != null)
     294                return false;
     295        } else if (!user.equals(other.user))
     296            return false;
     297        return true;
     298    }
     299
     300    public boolean hasKeys() {
     301        return !tags.keySet().isEmpty();
     302    }
     303
     304    public Collection<String> keySet() {
     305        return tags.keySet();
    70306    }
    71307}

  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r2077 r2115  
    326326        Collection<? extends OsmPrimitive> primitives = null;
    327327        switch(type) {
    328         case NODE: primitives = nodes; break;
    329         case WAY: primitives = ways; break;
    330         case RELATION: primitives = relations; break;
    331         case CHANGESET: throw new IllegalArgumentException(tr("unsupported value ''{0}'' or parameter ''{1}''", type, "type"));
     328            case NODE: primitives = nodes; break;
     329            case WAY: primitives = ways; break;
     330            case RELATION: primitives = relations; break;
    332331        }
    333332        for (OsmPrimitive primitive : primitives) {

  • trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r2083 r2115  
    3333 * @author imi
    3434 */
    35 abstract public class OsmPrimitive implements Comparable<OsmPrimitive> {
     35abstract public class OsmPrimitive implements Comparable<OsmPrimitive>, Tagged {
    3636
    3737    static public <T extends OsmPrimitive>  List<T> getFilteredList(Collection<OsmPrimitive> list, Class<T> type) {

  • trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitiveType.java

    r2077 r2115  
    77    NODE ("node"),
    88    WAY  ("way"),
    9     RELATION ("relation"),
    10     CHANGESET ("changeset");
     9    RELATION ("relation");
    1110
    1211    private String apiTypeName;
    … …  
    3534        if (cls.equals(Way.class)) return WAY;
    3635        if (cls.equals(Relation.class)) return RELATION;
    37         if (cls.equals(Changeset.class)) return CHANGESET;
    3836        throw new IllegalArgumentException(tr("parameter ''{0}'' is not an acceptable class, got ''{1}''", "cls", cls.toString()));
    3937    }

  • trunk/src/org/openstreetmap/josm/gui/MainMenu.java

    r2061 r2115  
    5858import org.openstreetmap.josm.actions.ShowStatusReportAction;
    5959import org.openstreetmap.josm.actions.SplitWayAction;
    60 import org.openstreetmap.josm.actions.StopChangesetAction;
     60import org.openstreetmap.josm.actions.CloseChangesetAction;
    6161import org.openstreetmap.josm.actions.ToggleGPXLinesAction;
    6262import org.openstreetmap.josm.actions.UnGlueAction;
    … …  
    100100    public final DownloadAction download = new DownloadAction();
    101101    public final DownloadReferrersAction downloadReferrers = new DownloadReferrersAction();
    102     public final StopChangesetAction stopChangesetAction = new StopChangesetAction();
     102    public final CloseChangesetAction closeChangesetAction = new CloseChangesetAction();
    103103    public final JosmAction update = new UpdateDataAction();
    104104    public final JosmAction updateSelection = new UpdateSelectionAction();
    … …  
    208208        add(fileMenu, update);
    209209        add(fileMenu, updateSelection);
    210         add(fileMenu, stopChangesetAction);
     210        add(fileMenu, closeChangesetAction);
    211211        fileMenu.addSeparator();
    212212        add(fileMenu, exit);

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/PasteTagsConflictResolverDialog.java

    r2070 r2115  
    8080        resolvers = new HashMap<OsmPrimitiveType, TagConflictResolver>();
    8181        for (OsmPrimitiveType type: OsmPrimitiveType.values()) {
    82             if (type.equals(OsmPrimitiveType.CHANGESET)) {
    83                 continue;
    84             }
    8582            resolvers.put(type, new TagConflictResolver());
    8683            resolvers.get(type).getModel().addPropertyChangeListener(this);
    … …  
    148145        String msg = "";
    149146        switch(type) {
    150         case NODE: msg= trn("{0} node", "{0} nodes", count, count); break;
    151         case WAY: msg= trn("{0} way", "{0} ways", count, count); break;
    152         case RELATION: msg= trn("{0} relation", "{0} relations", count, count); break;
     147            case NODE: msg= trn("{0} node", "{0} nodes", count, count); break;
     148            case WAY: msg= trn("{0} way", "{0} ways", count, count); break;
     149            case RELATION: msg= trn("{0} relation", "{0} relations", count, count); break;
    153150        }
    154151        return msg;
    … …  
    446443                String msg = "";
    447444                switch(type) {
    448                 case NODE: msg = trn("{0} node", "{0} nodes", numPrimitives,numPrimitives); break;
    449                 case WAY: msg = trn("{0} way", "{0} ways", numPrimitives, numPrimitives); break;
    450                 case RELATION: msg = trn("{0} relation", "{0} relations", numPrimitives, numPrimitives); break;
     445                    case NODE: msg = trn("{0} node", "{0} nodes", numPrimitives,numPrimitives); break;
     446                    case WAY: msg = trn("{0} way", "{0} ways", numPrimitives, numPrimitives); break;
     447                    case RELATION: msg = trn("{0} relation", "{0} relations", numPrimitives, numPrimitives); break;
    451448                }
    452449                text = text.equals("") ? msg : text + ", " + msg;
    … …  
    472469                String msg = "";
    473470                switch(type) {
    474                 case NODE: msg = trn("{0} node", "{0} nodes", numPrimitives,numPrimitives); break;
    475                 case WAY: msg = trn("{0} way", "{0} ways", numPrimitives, numPrimitives); break;
    476                 case RELATION: msg = trn("{0} relation", "{0} relations", numPrimitives, numPrimitives); break;
     471                    case NODE: msg = trn("{0} node", "{0} nodes", numPrimitives,numPrimitives); break;
     472                    case WAY: msg = trn("{0} way", "{0} ways", numPrimitives, numPrimitives); break;
     473                    case RELATION: msg = trn("{0} relation", "{0} relations", numPrimitives, numPrimitives); break;
    477474                }
    478475                text = text.equals("") ? msg : text + ", " + msg;
    … …  
    491488
    492489                switch(column) {
    493                 case 0: renderNumTags(info); break;
    494                 case 1: renderFrom(info); break;
    495                 case 2: renderTo(info); break;
     490                    case 0: renderNumTags(info); break;
     491                    case 1: renderFrom(info); break;
     492                    case 2: renderTo(info); break;
    496493                }
    497494            }

  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayersDialog.java

    r2096 r2115  
    3333import org.openstreetmap.josm.Main;
    3434import org.openstreetmap.josm.actions.UploadAction;
    35 import org.openstreetmap.josm.actions.UploadAction.UploadConfirmationHook;
    3635import org.openstreetmap.josm.gui.ExceptionDialogUtil;
    3736import org.openstreetmap.josm.gui.SideButton;
    … …  
    299298        public void cancel() {
    300299            switch(model.getMode()) {
    301             case EDITING_DATA: cancelWhenInEditingModel(); break;
    302             case UPLOADING_AND_SAVING: cancelSafeAndUploadTask(); break;
     300                case EDITING_DATA: cancelWhenInEditingModel(); break;
     301                case UPLOADING_AND_SAVING: cancelSafeAndUploadTask(); break;
    303302            }
    304303        }
    … …  
    334333                Mode mode = (Mode)evt.getNewValue();
    335334                switch(mode) {
    336                 case EDITING_DATA: setEnabled(true); break;
    337                 case UPLOADING_AND_SAVING: setEnabled(false); break;
     335                    case EDITING_DATA: setEnabled(true); break;
     336                    case UPLOADING_AND_SAVING: setEnabled(false); break;
    338337                }
    339338            }
    … …  
    368367                SaveLayersModel.Mode mode = (SaveLayersModel.Mode)evt.getNewValue();
    369368                switch(mode) {
    370                 case EDITING_DATA: setEnabled(true); break;
    371                 case UPLOADING_AND_SAVING: setEnabled(false); break;
     369                    case EDITING_DATA: setEnabled(true); break;
     370                    case UPLOADING_AND_SAVING: setEnabled(false); break;
    372371                }
    373372            }
    … …  
    411410                        layerInfo.getLayer(),
    412411                        monitor,
    413                         UploadAction.UploadConfirmationHook.getUploadDialog().getChangeset(),
    414                         UploadAction.UploadConfirmationHook.getUploadDialog().getChangesetProcessingType()
     412                        UploadDialog.getUploadDialog().getChangeset(),
     413                        UploadDialog.getUploadDialog().isDoCloseAfterUpload()
    415414                );
    416415                currentFuture = worker.submit(currentTask);

  • trunk/src/org/openstreetmap/josm/gui/io/UploadDialog.java

    r2081 r2115  
    66
    77import java.awt.BorderLayout;
     8import java.awt.Component;
    89import java.awt.Dimension;
    910import java.awt.FlowLayout;
    … …  
    1213import java.awt.event.ActionEvent;
    1314import java.awt.event.ActionListener;
     15import java.awt.event.ItemEvent;
     16import java.awt.event.ItemListener;
    1417import java.awt.event.WindowAdapter;
    1518import java.awt.event.WindowEvent;
     19import java.text.SimpleDateFormat;
    1620import java.util.ArrayList;
    17 import java.util.HashMap;
     21import java.util.Collection;
     22import java.util.Collections;
    1823import java.util.LinkedList;
    1924import java.util.List;
    20 import java.util.Map;
    2125
    2226import javax.swing.AbstractAction;
    2327import javax.swing.AbstractListModel;
    2428import javax.swing.BorderFactory;
    25 import javax.swing.BoxLayout;
    2629import javax.swing.ButtonGroup;
     30import javax.swing.DefaultComboBoxModel;
     31import javax.swing.ImageIcon;
     32import javax.swing.JButton;
    2733import javax.swing.JCheckBox;
     34import javax.swing.JComboBox;
    2835import javax.swing.JDialog;
    2936import javax.swing.JLabel;
    … …  
    3441import javax.swing.JScrollPane;
    3542import javax.swing.JTabbedPane;
     43import javax.swing.ListCellRenderer;
     44import javax.swing.UIManager;
    3645import javax.swing.event.ChangeEvent;
    3746import javax.swing.event.ChangeListener;
     47import javax.swing.event.ListDataEvent;
     48import javax.swing.event.ListDataListener;
    3849
    3950import org.openstreetmap.josm.Main;
    … …  
    4657import org.openstreetmap.josm.gui.tagging.TagEditorPanel;
    4758import org.openstreetmap.josm.gui.tagging.TagModel;
    48 import org.openstreetmap.josm.io.ChangesetProcessingType;
    4959import org.openstreetmap.josm.io.OsmApi;
    5060import org.openstreetmap.josm.tools.GBC;
    … …  
    6070public class UploadDialog extends JDialog {
    6171
     72
    6273    public static final String HISTORY_KEY = "upload.comment.history";
     74
     75    /**  the unique instance of the upload dialog */
     76    static private UploadDialog uploadDialog;
     77
     78    /**
     79     * Replies the unique instance of the upload dialog
     80     *
     81     * @return the unique instance of the upload dialog
     82     */
     83    static public UploadDialog getUploadDialog() {
     84        if (uploadDialog == null) {
     85            uploadDialog = new UploadDialog();
     86        }
     87        return uploadDialog;
     88    }
    6389
    6490    /** the list with the added primitives */
    … …  
    77103    private JPanel pnlLists;
    78104    /** checkbox for selecting whether an atomic upload is to be used  */
    79     private JCheckBox cbUseAtomicUpload;
    80     /** input field for changeset comment */
    81     private SuggestingJHistoryComboBox cmt;
    82     /** ui component for editing changeset tags */
    83105    private TagEditorPanel tagEditorPanel;
    84106    /** the tabbed pane used below of the list of primitives  */
    85107    private JTabbedPane southTabbedPane;
    86     /** the button group with the changeset processing types */
    87     private ButtonGroup bgChangesetHandlingOptions;
    88     /** radio buttons for selecting a changeset processing type */
    89     private Map<ChangesetProcessingType, JRadioButton> rbChangesetHandlingOptions;
     108
     109    private ChangesetSelectionPanel pnlChangesetSelection;
    90110
    91111    private boolean canceled = false;
    … …  
    104124    }
    105125
    106     /**
    107      * builds the panel with the ui components for controlling how the changeset
    108      * should be processed (opening/closing a changeset)
    109      *
    110      * @return the panel with the ui components for controlling how the changeset
    111      * should be processed
    112      */
    113     protected JPanel buildChangesetHandlingControlPanel() {
    114         JPanel pnl = new JPanel();
    115         pnl.setLayout(new BoxLayout(pnl, BoxLayout.Y_AXIS));
    116         bgChangesetHandlingOptions = new ButtonGroup();
    117         rbChangesetHandlingOptions = new HashMap<ChangesetProcessingType, JRadioButton>();
    118         ChangesetProcessingTypeChangedAction a = new ChangesetProcessingTypeChangedAction();
    119         for(ChangesetProcessingType type: ChangesetProcessingType.values()) {
    120             rbChangesetHandlingOptions.put(type, new JRadioButton());
    121             rbChangesetHandlingOptions.get(type).addActionListener(a);
    122         }
    123         JRadioButton rb = rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_NEW_AND_CLOSE);
    124         rb.setText(tr("Use a new changeset and close it"));
    125         rb.setToolTipText(tr("Select to upload the data using a new changeset and to close the changeset after the upload"));
    126 
    127         rb = rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_NEW_AND_LEAVE_OPEN);
    128         rb.setText(tr("Use a new changeset and leave it open"));
    129         rb.setToolTipText(tr("Select to upload the data using a new changeset and to leave the changeset open after the upload"));
    130 
    131         pnl.add(new JLabel(tr("Upload to a new or to an existing changeset?")));
    132         pnl.add(rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_NEW_AND_CLOSE));
    133         pnl.add(rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_NEW_AND_LEAVE_OPEN));
    134         pnl.add(rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_EXISTING_AND_CLOSE));
    135         pnl.add(rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_EXISTING_AND_LEAVE_OPEN));
    136 
    137         for(ChangesetProcessingType type: ChangesetProcessingType.values()) {
    138             rbChangesetHandlingOptions.get(type).setVisible(false);
    139             bgChangesetHandlingOptions.add(rbChangesetHandlingOptions.get(type));
    140         }
    141         return pnl;
    142     }
    143 
    144     /**
    145      * build the panel with the widgets for controlling how the changeset should be processed
    146      * (atomic upload or not, comment, opening/closing changeset)
    147      *
    148      * @return
    149      */
    150     protected JPanel buildChangesetControlPanel() {
    151         JPanel pnl = new JPanel();
    152         pnl.setLayout(new BoxLayout(pnl, BoxLayout.Y_AXIS));
    153         pnl.add(cbUseAtomicUpload = new JCheckBox(tr("upload all changes in one request")));
    154         cbUseAtomicUpload.setToolTipText(tr("Enable to upload all changes in one request, disable to use one request per changed primitive"));
    155         boolean useAtomicUpload = Main.pref.getBoolean("osm-server.atomic-upload", true);
    156         cbUseAtomicUpload.setSelected(useAtomicUpload);
    157         cbUseAtomicUpload.setEnabled(OsmApi.getOsmApi().hasSupportForDiffUploads());
    158 
    159         pnl.add(buildChangesetHandlingControlPanel());
    160         return pnl;
    161     }
    162 
    163     /**
    164      * builds the upload control panel
    165      *
    166      * @return
    167      */
    168     protected JPanel buildUploadControlPanel() {
    169         JPanel pnl = new JPanel();
    170         pnl.setLayout(new GridBagLayout());
    171         pnl.add(new JLabel(tr("Provide a brief comment for the changes you are uploading:")), GBC.eol().insets(0, 5, 10, 3));
    172         cmt = new SuggestingJHistoryComboBox();
    173         List<String> cmtHistory = new LinkedList<String>(Main.pref.getCollection(HISTORY_KEY, new LinkedList<String>()));
    174         cmt.setHistory(cmtHistory);
    175         cmt.getEditor().addActionListener(
    176                 new ActionListener() {
    177                     public void actionPerformed(ActionEvent e) {
    178                         TagModel tm = tagEditorPanel.getModel().get("comment");
    179                         if (tm == null) {
    180                             tagEditorPanel.getModel().add(new TagModel("comment", cmt.getText()));
    181                         } else {
    182                             tm.setValue(cmt.getText());
    183                         }
    184                         tagEditorPanel.getModel().fireTableDataChanged();
    185                     }
    186                 }
    187         );
    188         pnl.add(cmt, GBC.eol().fill(GBC.HORIZONTAL));
    189 
    190         // configuration options for atomic upload
    191         //
    192         pnl.add(buildChangesetControlPanel(), GBC.eol().fill(GridBagConstraints.HORIZONTAL));
    193         return pnl;
    194     }
    195126
    196127    protected JPanel buildContentPanel() {
    … …  
    211142        //
    212143        southTabbedPane = new JTabbedPane();
    213         southTabbedPane.add(buildUploadControlPanel());
     144        southTabbedPane.add(new JPanel());
    214145        tagEditorPanel = new TagEditorPanel();
    215146        southTabbedPane.add(tagEditorPanel);
     147        southTabbedPane.setComponentAt(0, pnlChangesetSelection = new ChangesetSelectionPanel());
    216148        southTabbedPane.setTitleAt(0, tr("Settings"));
    217149        southTabbedPane.setTitleAt(1, tr("Tags of new changeset"));
    … …  
    340272
    341273    /**
    342      * Replies true if a valid changeset comment has been entered in this dialog
    343      *
    344      * @return true if a valid changeset comment has been entered in this dialog
    345      */
    346     public boolean hasChangesetComment() {
    347         if (!getChangesetProcessingType().isUseNew())
    348             return true;
    349         return cmt.getText().trim().length() >= 3;
    350     }
    351 
    352     /**
    353274     * Remembers the user input in the preference settings
    354275     */
    355276    public void rememberUserInput() {
    356         // store the history of comments
    357         cmt.addCurrentItemToHistory();
    358         Main.pref.putCollection(HISTORY_KEY, cmt.getHistory());
    359         Main.pref.put("osm-server.atomic-upload", cbUseAtomicUpload.isSelected());
     277        pnlChangesetSelection.rememberUserInput();
    360278    }
    361279
    … …  
    365283    public void startUserInput() {
    366284        tagEditorPanel.initAutoCompletion(Main.main.getEditLayer());
    367         initChangesetProcessingType();
    368         cmt.getEditor().selectAll();
    369         cmt.requestFocus();
    370     }
    371 
    372     /**
    373      * Replies the current changeset processing type
    374      *
    375      * @return the current changeset processing type
    376      */
    377     public ChangesetProcessingType getChangesetProcessingType() {
    378         ChangesetProcessingType changesetProcessingType = null;
    379         for (ChangesetProcessingType type: ChangesetProcessingType.values()) {
    380             if (rbChangesetHandlingOptions.get(type).isSelected()) {
    381                 changesetProcessingType = type;
    382                 break;
    383             }
    384         }
    385         return changesetProcessingType == null ?
    386                 ChangesetProcessingType.USE_NEW_AND_CLOSE :
    387                     changesetProcessingType;
     285        pnlChangesetSelection.startUserInput();
    388286    }
    389287
    … …  
    394292     */
    395293    public Changeset getChangeset() {
    396         Changeset changeset = new Changeset();
    397         tagEditorPanel.getModel().applyToPrimitive(changeset);
    398         changeset.put("comment", cmt.getText());
    399         return changeset;
    400     }
    401 
    402     /**
    403      * initializes the panel depending on the possible changeset processing
    404      * types
    405      */
    406     protected void initChangesetProcessingType() {
    407         for (ChangesetProcessingType type: ChangesetProcessingType.values()) {
    408             // show options for new changeset, disable others
    409             //
    410             rbChangesetHandlingOptions.get(type).setVisible(type.isUseNew());
    411         }
    412         if (OsmApi.getOsmApi().getCurrentChangeset() != null) {
    413             Changeset cs = OsmApi.getOsmApi().getCurrentChangeset();
    414             for (ChangesetProcessingType type: ChangesetProcessingType.values()) {
    415                 // show options for using existing changeset
    416                 //
    417                 if (!type.isUseNew()) {
    418                     rbChangesetHandlingOptions.get(type).setVisible(true);
    419                 }
    420             }
    421             JRadioButton rb = rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_EXISTING_AND_CLOSE);
    422             rb.setText(tr("Use the existing changeset {0} and close it after upload",cs.getId()));
    423             rb.setToolTipText(tr("Select to upload to the existing changeset {0} and to close the changeset after this upload",cs.getId()));
    424 
    425             rb = rbChangesetHandlingOptions.get(ChangesetProcessingType.USE_EXISTING_AND_LEAVE_OPEN);
    426             rb.setText(tr("Use the existing changeset {0} and leave it open",cs.getId()));
    427             rb.setToolTipText(tr("Select to upload to the existing changeset {0} and to leave the changeset open for further uploads",cs.getId()));
    428 
    429             rbChangesetHandlingOptions.get(getChangesetProcessingType()).setSelected(true);
    430 
    431         } else {
    432             ChangesetProcessingType type = getChangesetProcessingType();
    433             if (!type.isUseNew()) {
    434                 type = ChangesetProcessingType.USE_NEW_AND_CLOSE;
    435             }
    436             rbChangesetHandlingOptions.get(type).setSelected(true);
    437         }
    438         ChangesetProcessingType type = getChangesetProcessingType();
    439         if (type.isUseNew() || (! type.isUseNew() && OsmApi.getOsmApi().getCurrentChangeset() == null)) {
    440             Changeset cs = new Changeset();
    441             cs.put("created_by", getDefaultCreatedBy());
    442             tagEditorPanel.getModel().initFromPrimitive(cs);
    443         } else {
    444             Changeset cs = OsmApi.getOsmApi().getCurrentChangeset();
    445             tagEditorPanel.getModel().initFromPrimitive(cs);
    446         }
     294        Changeset cs = pnlChangesetSelection.getChangeset();
     295        tagEditorPanel.getModel().applyToPrimitive(cs);
     296        cs.put("comment", getUploadComment());
     297        return cs;
     298    }
     299
     300    /**
     301     * Sets or updates the changeset cs.
     302     * If cs is null, does nothing.
     303     * If cs.getId() == 0 does nothing.
     304     * If cs.getId() > 0 and cs is open, adds it to the list of open
     305     * changesets. If it is closed, removes it from the list of open
     306     * changesets.
     307     *
     308     * @param cs the changeset
     309     */
     310    public void setOrUpdateChangeset(Changeset cs) {
     311        pnlChangesetSelection.setOrUpdateChangeset(cs);
     312    }
     313
     314    public boolean isDoCloseAfterUpload() {
     315        return pnlChangesetSelection.isCloseAfterUpload();
    447316    }
    448317
    … …  
    457326    }
    458327
    459     /**
    460      * refreshes  the panel depending on a changeset processing type
    461      *
    462      * @param type the changeset processing type
    463      */
    464     protected void switchToProcessingType(ChangesetProcessingType type) {
    465         if (type.isUseNew()) {
    466             southTabbedPane.setTitleAt(1, tr("Tags of new changeset"));
    467             // init a new changeset from the currently edited tags
    468             // and the comment field
    469             //
    470             Changeset cs = new Changeset(getChangeset());
    471             if (cs.get("created_by") == null) {
    472                 cs.put("created_by", getDefaultCreatedBy());
    473             }
    474             cs.put("comment", this.cmt.getText());
    475             tagEditorPanel.getModel().initFromPrimitive(cs);
    476         } else {
    477             Changeset cs = OsmApi.getOsmApi().getCurrentChangeset();
    478             if (cs != null) {
    479                 cs.put("comment", this.cmt.getText());
    480                 cs.setKeys(getChangeset().getKeys());
    481                 southTabbedPane.setTitleAt(1, tr("Tags of changeset {0}", cs.getId()));
    482                 tagEditorPanel.getModel().initFromPrimitive(cs);
    483             }
    484         }
    485     }
    486 
    487     public String getUploadComment() {
     328    protected String getUploadComment() {
    488329        switch(southTabbedPane.getSelectedIndex()) {
    489         case 0: return cmt.getText();
    490         case 1:
    491             TagModel tm = tagEditorPanel.getModel().get("comment");
    492             return tm == null? "" : tm.getValue();
     330            case 0:
     331                pnlChangesetSelection.getUploadComment();
     332            case 1:
     333                TagModel tm = tagEditorPanel.getModel().get("comment");
     334                return tm == null? "" : tm.getValue();
    493335        }
    494336        return "";
    … …  
    509351                    getClass().getName() + ".geometry",
    510352                    WindowGeometry.centerInWindow(
    511                             JOptionPane.getFrameForComponent(Main.parent),
     353                            Main.parent,
    512354                            new Dimension(400,600)
    513355                    )
    … …  
    520362    }
    521363
    522     class ChangesetProcessingTypeChangedAction implements ActionListener {
    523         public void actionPerformed(ActionEvent e) {
    524             ChangesetProcessingType type = getChangesetProcessingType();
    525             switchToProcessingType(type);
    526         }
    527     }
    528 
    529 
     364    /**
     365     * This change listener is triggered when current tab in the tabbed pane in
     366     * the lower half of the dialog is changed.
     367     *
     368     * It's main purpose is to keep the content in the text field for the changeset
     369     * comment in sync with the changeset tag "comment".
     370     *
     371     */
    530372    class TabbedPaneChangeLister implements ChangeListener {
    531373
    … …  
    560402            TagModel tm = getOrCreateCommentTag();
    561403            tm.setName("comment");
    562             tm.setValue(cmt.getText().trim());
    563             if (cmt.getText().trim().equals("")) {
     404            tm.setValue(pnlChangesetSelection.getUploadComment().trim());
     405            if (pnlChangesetSelection.getUploadComment().trim().equals("")) {
    564406                removeCommentTag();
    565407            }
    566408            tagEditorPanel.getModel().fireTableDataChanged();
    567409        }
    568 
    569410
    570411        public void stateChanged(ChangeEvent e) {
    571412            if (southTabbedPane.getSelectedIndex() ==0) {
    572413                TagModel tm = tagEditorPanel.getModel().get("comment");
    573                 cmt.setText(tm == null ? "" : tm.getValue());
    574                 cmt.getEditor().selectAll();
    575                 cmt.requestFocus();
     414                pnlChangesetSelection.initEditingOfUploadComment(tm == null ? "" : tm.getValue());
    576415            } else if (southTabbedPane.getSelectedIndex() == 1) {
    577416                refreshCommentTag();
    … …  
    580419    }
    581420
     421    /**
     422     * Handles an upload
     423     *
     424     */
    582425    class UploadAction extends AbstractAction {
    583426        public UploadAction() {
    … …  
    599442            if (getUploadComment().trim().length() < 3) {
    600443                warnIllegalUploadComment();
    601                 cmt.getEditor().selectAll();
    602                 cmt.requestFocus();
     444                southTabbedPane.setSelectedIndex(0);
     445                pnlChangesetSelection.initEditingOfUploadComment(getUploadComment());
    603446                return;
    604447            }
    … …  
    609452    }
    610453
     454    /**
     455     * Action for canceling the dialog
     456     *
     457     */
    611458    class CancelAction extends AbstractAction {
    612459        public CancelAction() {
    … …  
    623470    }
    624471
     472    /**
     473     * A simple list of OSM primitives.
     474     *
     475     */
    625476    class PrimitiveList extends JList {
    626477        public PrimitiveList() {
    … …  
    633484    }
    634485
     486    /**
     487     * A list model for a list of OSM primitives.
     488     *
     489     */
    635490    class PrimitiveListModel extends AbstractListModel{
    636491        private List<OsmPrimitive> primitives;
    … …  
    664519    }
    665520
     521    /**
     522     * Listens to window closing events and processes them as cancel events
     523     *
     524     */
    666525    class WindowClosingAdapter extends WindowAdapter {
    667526        @Override
    … …  
    670529        }
    671530    }
     531
     532    /**
     533     * The panel which provides various UI widgets for controlling how to use
     534     * changesets during upload.
     535     *
     536     */
     537    class ChangesetSelectionPanel extends JPanel implements ListDataListener{
     538
     539        private ButtonGroup bgUseNewOrExisting;
     540        private JRadioButton rbUseNew;
     541        private JRadioButton rbExisting;
     542        private JComboBox cbOpenChangesets;
     543        private JButton btnRefresh;
     544        private JButton btnClose;
     545        private JCheckBox cbCloseAfterUpload;
     546        private OpenChangesetModel model;
     547        private SuggestingJHistoryComboBox cmt;
     548        private JCheckBox cbUseAtomicUpload;
     549
     550        /**
     551         * build the panel with the widgets for controlling whether an atomic upload
     552         * should be used or not
     553         *
     554         * @return the panel
     555         */
     556        protected JPanel buildAtomicUploadControlPanel() {
     557            JPanel pnl = new JPanel();
     558            pnl.setLayout(new GridBagLayout());
     559            GridBagConstraints gc = new GridBagConstraints();
     560            gc.fill = GridBagConstraints.HORIZONTAL;
     561            gc.weightx = 1.0;
     562            gc.anchor = GridBagConstraints.FIRST_LINE_START;
     563            pnl.add(cbUseAtomicUpload = new JCheckBox(tr("Upload all changes in one request")), gc);
     564            cbUseAtomicUpload.setToolTipText(tr("Enable to upload all changes in one request, disable to use one request per changed primitive"));
     565            boolean useAtomicUpload = Main.pref.getBoolean("osm-server.atomic-upload", true);
     566            cbUseAtomicUpload.setSelected(useAtomicUpload);
     567            cbUseAtomicUpload.setEnabled(OsmApi.getOsmApi().hasSupportForDiffUploads());
     568            return pnl;
     569        }
     570
     571        protected JPanel buildUploadCommentPanel() {
     572            JPanel pnl = new JPanel();
     573            pnl.setLayout(new GridBagLayout());
     574            pnl.add(new JLabel(tr("Provide a brief comment for the changes you are uploading:")), GBC.eol().insets(0, 5, 10, 3));
     575            cmt = new SuggestingJHistoryComboBox();
     576            List<String> cmtHistory = new LinkedList<String>(Main.pref.getCollection(HISTORY_KEY, new LinkedList<String>()));
     577            cmt.setHistory(cmtHistory);
     578            cmt.getEditor().addActionListener(
     579                    new ActionListener() {
     580                        public void actionPerformed(ActionEvent e) {
     581                            TagModel tm = tagEditorPanel.getModel().get("comment");
     582                            if (tm == null) {
     583                                tagEditorPanel.getModel().add(new TagModel("comment", cmt.getText()));
     584                            } else {
     585                                tm.setValue(cmt.getText());
     586                            }
     587                            tagEditorPanel.getModel().fireTableDataChanged();
     588                        }
     589                    }
     590            );
     591            pnl.add(cmt, GBC.eol().fill(GBC.HORIZONTAL));
     592            return pnl;
     593        }
     594
     595        protected void build() {
     596            setLayout(new GridBagLayout());
     597            GridBagConstraints gc = new GridBagConstraints();
     598
     599            bgUseNewOrExisting = new ButtonGroup();
     600
     601            // -- atomic upload
     602            gc.gridwidth = 4;
     603            gc.gridy = 0;
     604            gc.fill = GridBagConstraints.HORIZONTAL;
     605            gc.weightx = 1.0;
     606            gc.anchor = GridBagConstraints.FIRST_LINE_START;
     607            add(buildAtomicUploadControlPanel(), gc);
     608
     609            // -- changeset command
     610            gc.gridwidth = 4;
     611            gc.gridy = 1;
     612            gc.fill = GridBagConstraints.HORIZONTAL;
     613            gc.weightx = 1.0;
     614            gc.anchor = GridBagConstraints.FIRST_LINE_START;
     615            add(buildUploadCommentPanel(), gc);
     616
     617            gc.gridwidth = 4;
     618            gc.gridy = 2;
     619            gc.fill = GridBagConstraints.HORIZONTAL;
     620            gc.weightx = 0.0;
     621            gc.anchor = GridBagConstraints.FIRST_LINE_START;
     622            rbUseNew = new JRadioButton(tr("Open a new changeset"));
     623            rbUseNew.setToolTipText(tr("Open a new changeset and use it in the next upload"));
     624            bgUseNewOrExisting.add(rbUseNew);
     625            add(rbUseNew, gc);
     626
     627            gc.gridx = 0;
     628            gc.gridy = 3;
     629            gc.gridwidth = 1;
     630            rbExisting = new JRadioButton(tr("Use an open changeset"));
     631            rbExisting.setToolTipText(tr("Upload data to an already opened changeset"));
     632            bgUseNewOrExisting.add(rbExisting);
     633            add(rbExisting, gc);
     634
     635            gc.gridx = 1;
     636            gc.gridy = 3;
     637            gc.gridwidth = 1;
     638            gc.weightx = 1.0;
     639            model = new OpenChangesetModel();
     640            cbOpenChangesets = new JComboBox(model);
     641            cbOpenChangesets.setToolTipText("Select an open changeset");
     642            cbOpenChangesets.setRenderer(new ChangesetCellRenderer());
     643            cbOpenChangesets.addItemListener(new ChangesetListItemStateListener());
     644            Dimension d = cbOpenChangesets.getPreferredSize();
     645            d.width = 200;
     646            cbOpenChangesets.setPreferredSize(d);
     647            d.width = 100;
     648            cbOpenChangesets.setMinimumSize(d);
     649            model.addListDataListener(this);
     650            add(cbOpenChangesets, gc);
     651
     652            gc.gridx = 3;
     653            gc.gridy = 3;
     654            gc.gridwidth = 1;
     655            gc.weightx = 0.0;
     656            btnRefresh = new JButton(new RefreshAction());
     657            add(btnRefresh, gc);
     658
     659            gc.gridx = 4;
     660            gc.gridy = 3;
     661            gc.gridwidth = 1;
     662            gc.weightx = 0.0;
     663            CloseChangesetAction closeChangesetAction = new CloseChangesetAction();
     664            btnClose = new JButton(closeChangesetAction);
     665            cbOpenChangesets.addItemListener(closeChangesetAction);
     666            add(btnClose, gc);
     667
     668            gc.gridx = 0;
     669            gc.gridy = 4;
     670            gc.gridwidth = 4;
     671            cbCloseAfterUpload = new JCheckBox(tr("Close changeset after upload"));
     672            cbCloseAfterUpload.setToolTipText(tr("Select to close the changeset after the next upload"));
     673            add(cbCloseAfterUpload, gc);
     674            cbCloseAfterUpload.setSelected(true);
     675
     676            rbUseNew.getModel().addItemListener(new RadioButtonHandler());
     677            rbExisting.getModel().addItemListener(new RadioButtonHandler());
     678
     679            refreshGUI();
     680        }
     681
     682        public ChangesetSelectionPanel() {
     683            build();
     684        }
     685
     686        /**
     687         * Remembers the user input in the preference settings
     688         */
     689        public void rememberUserInput() {
     690            // store the history of comments
     691            cmt.addCurrentItemToHistory();
     692            Main.pref.putCollection(HISTORY_KEY, cmt.getHistory());
     693            Main.pref.put("osm-server.atomic-upload", cbUseAtomicUpload.isSelected());
     694        }
     695
     696        /**
     697         * Initializes the panel for user input
     698         */
     699        public void startUserInput() {
     700            cmt.getEditor().selectAll();
     701            cmt.requestFocus();
     702        }
     703
     704        /**
     705         * Replies the current upload comment
     706         *
     707         * @return
     708         */
     709        public String getUploadComment() {
     710            return cmt.getText();
     711        }
     712
     713        /**
     714         * Replies the current upload comment
     715         *
     716         * @return
     717         */
     718        public void setUploadComment(String uploadComment) {
     719            cmt.setText(uploadComment);
     720        }
     721
     722        public void initEditingOfUploadComment(String comment) {
     723            setUploadComment(comment);
     724            cmt.getEditor().selectAll();
     725            cmt.requestFocus();
     726        }
     727
     728        protected void refreshGUI() {
     729            rbExisting.setEnabled(model.getSize() > 0);
     730            if (model.getSize() == 0) {
     731                if (!rbUseNew.isSelected()) {
     732                    rbUseNew.setSelected(true);
     733                }
     734            }
     735            cbOpenChangesets.setEnabled(model.getSize() > 0 && rbExisting.isSelected());
     736        }
     737
     738        public void contentsChanged(ListDataEvent e) {
     739            refreshGUI();
     740        }
     741
     742        public void intervalAdded(ListDataEvent e) {
     743            refreshGUI();
     744        }
     745
     746        public void intervalRemoved(ListDataEvent e) {
     747            refreshGUI();
     748        }
     749
     750        public Changeset getChangeset() {
     751            if (rbUseNew.isSelected() || cbOpenChangesets.getSelectedItem() == null)
     752                return new Changeset();
     753            Changeset cs = (Changeset)cbOpenChangesets.getSelectedItem();
     754            if (cs == null)
     755                return new Changeset();
     756            return cs;
     757        }
     758
     759        public void setOrUpdateChangeset(Changeset cs) {
     760            if (cs == null) {
     761                tagEditorPanel.getModel().clear();
     762                tagEditorPanel.getModel().add("created_by", getDefaultCreatedBy());
     763                tagEditorPanel.getModel().appendNewTag();
     764                rbUseNew.setSelected(true);
     765            } else if (cs.getId() == 0) {
     766                if (cs.get("created_by") == null) {
     767                    cs.put("created_by", getDefaultCreatedBy());
     768                }
     769                tagEditorPanel.getModel().initFromPrimitive(cs);
     770                tagEditorPanel.getModel().appendNewTag();
     771                rbUseNew.setSelected(true);
     772            } else if (cs.getId() > 0 && cs.isOpen()){
     773                if (cs.get("created_by") == null) {
     774                    cs.put("created_by", getDefaultCreatedBy());
     775                }
     776                tagEditorPanel.getModel().initFromPrimitive(cs);
     777                model.addOrUpdate(cs);
     778                cs = model.getChangesetById(cs.getId());
     779                cbOpenChangesets.setSelectedItem(cs);
     780            } else if (cs.getId() > 0 && !cs.isOpen()){
     781                if (cs.get("created_by") == null) {
     782                    cs.put("created_by", getDefaultCreatedBy());
     783                }
     784                tagEditorPanel.getModel().initFromPrimitive(cs);
     785                model.removeChangeset(cs);
     786                if (model.getSize() == 0) {
     787                    rbUseNew.setSelected(true);
     788                    model.setSelectedItem(null);
     789                    southTabbedPane.setTitleAt(1, tr("Tags of new changeset"));
     790                }
     791            }
     792        }
     793
     794        public void setUseNew() {
     795            rbUseNew.setSelected(true);
     796        }
     797
     798        public void setUseExisting() {
     799            rbExisting.setSelected(true);
     800            if (cbOpenChangesets.getSelectedItem() == null && model.getSize() > 0) {
     801                cbOpenChangesets.setSelectedItem(model.getElementAt(0));
     802            }
     803        }
     804
     805        public boolean isCloseAfterUpload() {
     806            return cbCloseAfterUpload.isSelected();
     807        }
     808
     809        class RadioButtonHandler implements ItemListener {
     810            public void itemStateChanged(ItemEvent e) {
     811                if (rbUseNew.isSelected()) {
     812                    southTabbedPane.setTitleAt(1, tr("Tags of new changeset"));
     813                    // init a new changeset from the currently edited tags
     814                    // and the comment field
     815                    //
     816                    Changeset cs = new Changeset();
     817                    tagEditorPanel.getModel().applyToPrimitive(cs);
     818                    if (cs.get("created_by") == null) {
     819                        cs.put("created_by", getDefaultCreatedBy());
     820                    }
     821                    cs.put("comment", cmt.getText());
     822                    tagEditorPanel.getModel().initFromPrimitive(cs);
     823                } else {
     824                    if (cbOpenChangesets.getSelectedItem() == null) {
     825                        model.selectFirstChangeset();
     826                    }
     827                    Changeset cs = (Changeset)cbOpenChangesets.getSelectedItem();
     828                    if (cs != null) {
     829                        cs.put("comment", cmt.getText());
     830                        southTabbedPane.setTitleAt(1, tr("Tags of changeset {0}", cs.getId()));
     831                        tagEditorPanel.getModel().initFromPrimitive(cs);
     832                    }
     833                }
     834                refreshGUI();
     835            }
     836        }
     837
     838        class ChangesetListItemStateListener implements ItemListener {
     839            public void itemStateChanged(ItemEvent e) {
     840
     841                Changeset cs = (Changeset)cbOpenChangesets.getSelectedItem();
     842                if (cs == null) {
     843                    southTabbedPane.setTitleAt(1, tr("Tags of new changeset"));
     844                    // init a new changeset from the currently edited tags
     845                    // and the comment field
     846                    //
     847                    cs = new Changeset();
     848                    tagEditorPanel.getModel().applyToPrimitive(cs);
     849                    if (cs.get("created_by") == null) {
     850                        cs.put("created_by", getDefaultCreatedBy());
     851                    }
     852                    cs.put("comment", cmt.getText());
     853                    tagEditorPanel.getModel().initFromPrimitive(cs);
     854                } else {
     855                    southTabbedPane.setTitleAt(1, tr("Tags of changeset {0}", cs.getId()));
     856                    cs.put("comment", cmt.getText());
     857                    southTabbedPane.setTitleAt(1, tr("Tags of changeset {0}", cs.getId()));
     858                    if (cs.get("created_by") == null) {
     859                        cs.put("created_by", getDefaultCreatedBy());
     860                    }
     861                    tagEditorPanel.getModel().initFromPrimitive(cs);
     862                }
     863            }
     864        }
     865
     866        class RefreshAction extends AbstractAction {
     867            public RefreshAction() {
     868                //putValue(NAME, tr("Reload"));
     869                putValue(SHORT_DESCRIPTION, tr("Load the list of your open changesets from the server"));
     870                putValue(SMALL_ICON, ImageProvider.get("dialogs", "refresh"));
     871            }
     872
     873            public void actionPerformed(ActionEvent e) {
     874                DownloadOpenChangesetsTask task = new DownloadOpenChangesetsTask(model);
     875                Main.worker.submit(task);
     876            }
     877        }
     878
     879        class CloseChangesetAction extends AbstractAction implements ItemListener{
     880            public CloseChangesetAction() {
     881                putValue(NAME, tr("Close"));
     882                putValue(SHORT_DESCRIPTION, tr("Close the currently selected open changeset"));
     883                refreshEnabledState();
     884            }
     885
     886            public void actionPerformed(ActionEvent e) {
     887                Changeset cs = (Changeset)cbOpenChangesets.getSelectedItem();
     888                if (cs == null) return;
     889                CloseChangesetTask task = new CloseChangesetTask(Collections.singletonList(cs));
     890                Main.worker.submit(task);
     891            }
     892
     893            protected void refreshEnabledState() {
     894                setEnabled(cbOpenChangesets.getModel().getSize() > 0 && cbOpenChangesets.getSelectedItem() != null);
     895            }
     896
     897            public void itemStateChanged(ItemEvent e) {
     898                refreshEnabledState();
     899            }
     900        }
     901    }
     902
     903    public class OpenChangesetModel extends DefaultComboBoxModel {
     904        private List<Changeset> changesets;
     905        private long uid;
     906        private Changeset selectedChangeset = null;
     907
     908        protected Changeset getChangesetById(long id) {
     909            for (Changeset cs : changesets) {
     910                if (cs.getId() == id) return cs;
     911            }
     912            return null;
     913        }
     914
     915        public OpenChangesetModel() {
     916            this.changesets = new ArrayList<Changeset>();
     917        }
     918
     919        protected void internalAddOrUpdate(Changeset cs) {
     920            Changeset other = getChangesetById(cs.getId());
     921            if (other != null) {
     922                cs.cloneFrom(other);
     923            } else {
     924                changesets.add(cs);
     925            }
     926        }
     927
     928        public void addOrUpdate(Changeset cs) {
     929            if (cs.getId() <= 0 )
     930                throw new IllegalArgumentException(tr("changeset id > 0 expected. Got {1}", "id", cs.getId()));
     931            internalAddOrUpdate(cs);
     932            fireContentsChanged(this, 0, getSize());
     933        }
     934
     935        public void remove(long id) {
     936            Changeset cs = getChangesetById(id);
     937            if (cs != null) {
     938                changesets.remove(cs);
     939            }
     940            fireContentsChanged(this, 0, getSize());
     941        }
     942
     943        public void addOrUpdate(Collection<Changeset> changesets) {
     944            for (Changeset cs: changesets) {
     945                internalAddOrUpdate(cs);
     946            }
     947            fireContentsChanged(this, 0, getSize());
     948            if (getSelectedItem() == null && !this.changesets.isEmpty()) {
     949                setSelectedItem(this.changesets.get(0));
     950            } else {
     951                setSelectedItem(null);
     952            }
     953        }
     954
     955        public void setUserId(long uid) {
     956            this.uid = uid;
     957        }
     958
     959        public long getUserId() {
     960            return uid;
     961        }
     962
     963        public void selectFirstChangeset() {
     964            if (changesets == null || changesets.isEmpty()) return;
     965            setSelectedItem(changesets.get(0));
     966        }
     967
     968        public void removeChangeset(Changeset cs) {
     969            if (cs == null) return;
     970            changesets.remove(cs);
     971            if (selectedChangeset == cs) {
     972                selectFirstChangeset();
     973            }
     974            fireContentsChanged(this, 0, getSize());
     975        }
     976        /* ------------------------------------------------------------------------------------ */
     977        /* ComboBoxModel                                                                        */
     978        /* ------------------------------------------------------------------------------------ */
     979        @Override
     980        public Object getElementAt(int index) {
     981            return changesets.get(index);
     982        }
     983
     984        @Override
     985        public int getIndexOf(Object anObject) {
     986            return changesets.indexOf(anObject);
     987        }
     988
     989        @Override
     990        public int getSize() {
     991            return changesets.size();
     992        }
     993
     994        @Override
     995        public Object getSelectedItem() {
     996            return selectedChangeset;
     997        }
     998
     999        @Override
     1000        public void setSelectedItem(Object anObject) {
     1001            if (anObject == null) {
     1002                this.selectedChangeset = null;
     1003                super.setSelectedItem(null);
     1004                return;
     1005            }
     1006            if (! (anObject instanceof Changeset)) return;
     1007            Changeset cs = (Changeset)anObject;
     1008            if (cs.getId() == 0 || ! cs.isOpen()) return;
     1009            Changeset candidate = getChangesetById(cs.getId());
     1010            if (candidate == null) return;
     1011            this.selectedChangeset = candidate;
     1012            super.setSelectedItem(selectedChangeset);
     1013        }
     1014    }
    6721015}

  • trunk/src/org/openstreetmap/josm/gui/io/UploadLayerTask.java

    r2040 r2115  
    3636    private ProgressMonitor monitor;
    3737    private Changeset changeset;
    38     private ChangesetProcessingType changesetProcessingType;
     38    private boolean closeChangesetAfterUpload;
    3939
    4040    /**
    … …  
    4444     * @param changeset the changeset to be used if <code>changesetProcessingType</code> indicates that a new
    4545     *   changeset is to be used
    46      * @param changesetProcessingType how we handle changesets
     46     * @param closeChangesetAfterUpload true, if the changeset should be closed after the upload
    4747     * @throws IllegalArgumentException thrown, if layer is null
    4848     */
    49     public UploadLayerTask(OsmDataLayer layer, ProgressMonitor monitor, Changeset changeset, ChangesetProcessingType changesetProcessingType) {
     49    public UploadLayerTask(OsmDataLayer layer, ProgressMonitor monitor, Changeset changeset, boolean closeChangesetAfterUpload) {
    5050        if (layer == null)
    5151            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", layer));
    … …  
    5656        this.monitor = monitor;
    5757        this.changeset = changeset;
    58         this.changesetProcessingType = changesetProcessingType == null ? ChangesetProcessingType.USE_NEW_AND_CLOSE : changesetProcessingType;
     58        this.closeChangesetAfterUpload = closeChangesetAfterUpload;
    5959    }
    6060
    … …  
    6969            ProgressMonitor m = monitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false);
    7070            if (isCancelled()) return;
    71             writer.uploadOsm(layer.data.version, toUpload, changeset, changesetProcessingType, m);
     71            writer.uploadOsm(layer.data.version, toUpload, changeset, closeChangesetAfterUpload, m);
    7272        } catch (Exception sxe) {
    7373            if (isCancelled()) {

  • trunk/src/org/openstreetmap/josm/gui/tagging/TagEditorModel.java

    r2081 r2115  
    99import java.util.Collection;
    1010import java.util.Comparator;
     11import java.util.HashMap;
    1112import java.util.Iterator;
    1213import java.util.List;
     14import java.util.Map;
    1315import java.util.logging.Logger;
    1416
    … …  
    1921import org.openstreetmap.josm.command.SequenceCommand;
    2022import org.openstreetmap.josm.data.osm.OsmPrimitive;
     23import org.openstreetmap.josm.data.osm.Tagged;
    2124
    2225
    … …  
    8386        TagModel tag = tags.get(rowIndex);
    8487        switch(columnIndex) {
    85         case 0:
    86         case 1: return tag;
    87 
    88         default:
    89             throw new IndexOutOfBoundsException("unexpected columnIndex: columnIndex=" + columnIndex);
     88            case 0:
     89            case 1: return tag;
     90
     91            default:
     92                throw new IndexOutOfBoundsException("unexpected columnIndex: columnIndex=" + columnIndex);
    9093        }
    9194    }
    … …  
    280283     * @param primitive the OSM primitive
    281284     */
    282     public void initFromPrimitive(OsmPrimitive primitive) {
     285    public void initFromPrimitive(Tagged primitive) {
    283286        clear();
    284287        for (String key : primitive.keySet()) {
    … …  
    293296
    294297    /**
     298     * initializes the model with the tags of an OSM primitive
     299     *
     300     * @param primitive the OSM primitive
     301     */
     302    public void initFromTags(Map<String,String> tags) {
     303        clear();
     304        for (String key : tags.keySet()) {
     305            String value = tags.get(key);
     306            add(key,value);
     307        }
     308        TagModel tag = new TagModel();
     309        sort();
     310        this.tags.add(tag);
     311        setDirty(false);
     312    }
     313
     314    /**
    295315     * applies the current state of the tag editor model to a primitive
    296316     *
    … …  
    298318     *
    299319     */
    300     public void applyToPrimitive(OsmPrimitive primitive) {
    301         primitive.removeAll();
    302         for (TagModel tag: tags) {
     320    public void applyToPrimitive(Tagged primitive) {
     321        Map<String,String> tags = primitive.getKeys();
     322        applyToTags(tags);
     323        primitive.setKeys(tags);
     324    }
     325
     326    /**
     327     * applies the current state of the tag editor model to a map of tags
     328     *
     329     * @param tags the map of key/value pairs
     330     *
     331     */
     332    public void applyToTags(Map<String, String> tags) {
     333        tags.clear();
     334        for (TagModel tag: this.tags) {
    303335            // tag still holds an unchanged list of different values for the same key.
    304336            // no property change command required
    … …  
    312344                continue;
    313345            }
    314             primitive.put(tag.getName(), tag.getValue());
    315         }
     346            tags.put(tag.getName(), tag.getValue());
     347        }
     348    }
     349
     350    public Map<String,String> getTags() {
     351        Map<String,String> tags = new HashMap<String, String>();
     352        applyToTags(tags);
     353        return tags;
    316354    }
    317355

  • trunk/src/org/openstreetmap/josm/io/OsmApi.java

    r2074 r2115  
    2323import java.util.Collections;
    2424import java.util.HashMap;
    25 import java.util.Properties;
    2625
    2726import javax.xml.parsers.SAXParserFactory;
    … …  
    3231import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    3332import org.openstreetmap.josm.data.osm.visitor.CreateOsmChangeVisitor;
     33import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
    3434import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    3535import org.xml.sax.Attributes;
    … …  
    205205
    206206    /**
     207     * Makes an XML string from an OSM primitive. Uses the OsmWriter class.
     208     * @param o the OSM primitive
     209     * @param addBody true to generate the full XML, false to only generate the encapsulating tag
     210     * @return XML string
     211     */
     212    private String toXml(Changeset s) {
     213        swriter.getBuffer().setLength(0);
     214        osmWriter.header();
     215        s.visit(osmWriter);
     216        osmWriter.footer();
     217        osmWriter.out.flush();
     218        return swriter.toString();
     219    }
     220
     221    /**
    207222     * Returns the base URL for API requests, including the negotiated version number.
    208223     * @return base URL string
    … …  
    229244     */
    230245    public void createPrimitive(OsmPrimitive osm, ProgressMonitor monitor) throws OsmTransferException {
    231         initialize(monitor);
    232246        String ret = "";
    233247        try {
     248            ensureValidChangeset();
     249            initialize(monitor);
    234250            ret = sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/create", toXml(osm, true),monitor);
    235251            osm.setOsmId(Long.parseLong(ret.trim()), 1);
    … …  
    244260     * version.
    245261     *
    246      * @param osm the primitive
     262     * @param osm the primitive. Must not be null
    247263     * @throws OsmTransferException if something goes wrong
    248264     */
    249265    public void modifyPrimitive(OsmPrimitive osm, ProgressMonitor monitor) throws OsmTransferException {
    250         initialize(monitor);
    251         if (version.equals("0.5")) {
    252             // legacy mode does not return the new object version.
    253             sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/" + osm.getId(), toXml(osm, true),monitor);
    254         } else {
    255             String ret = null;
    256             // normal mode (0.6 and up) returns new object version.
    257             try {
     266        String ret = null;
     267        try {
     268            ensureValidChangeset();
     269            initialize(monitor);
     270            if (version.equals("0.5")) {
     271                // legacy mode does not return the new object version.
     272                sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/" + osm.getId(), toXml(osm, true),monitor);
     273            } else {
     274                // normal mode (0.6 and up) returns new object version.
    258275                ret = sendRequest("PUT", OsmPrimitiveType.from(osm).getAPIName()+"/" + osm.getId(), toXml(osm, true), monitor);
    259276                osm.setOsmId(osm.getId(), Integer.parseInt(ret.trim()));
    260             } catch(NumberFormatException e) {
    261                 throw new OsmTransferException(tr("unexpected format of new version of modified primitive ''{0}'', got ''{1}''", osm.getId(), ret));
    262277            }
     278        } catch(NumberFormatException e) {
     279            throw new OsmTransferException(tr("unexpected format of new version of modified primitive ''{0}'', got ''{1}''", osm.getId(), ret));
    263280        }
    264281    }
    … …  
    270287     */
    271288    public void deletePrimitive(OsmPrimitive osm, ProgressMonitor monitor) throws OsmTransferException {
     289        ensureValidChangeset();
    272290        initialize(monitor);
    273291        // can't use a the individual DELETE method in the 0.6 API. Java doesn't allow
    … …  
    280298
    281299    /**
    282      * Creates a new changeset based on the keys in <code>changeset</code>
    283      *
    284      * @param changeset the changeset to be used for uploading
     300     * Creates a new changeset based on the keys in <code>changeset</code>. If this
     301     * method succeeds, changeset.getId() replies the id the server assigned to the new
     302     * changeset
     303     *
     304     * The changeset must not be null, but its key/value-pairs may be empty.
     305     *
     306     * @param changeset the changeset toe be created. Must not be null.
    285307     * @param progressMonitor the progress monitor
    286308     * @throws OsmTransferException signifying a non-200 return code, or connection errors
    287      */
    288     public void createChangeset(Changeset changeset, ProgressMonitor progressMonitor) throws OsmTransferException {
     309     * @throws IllegalArgumentException thrown if changeset is null
     310     */
     311    public void openChangeset(Changeset changeset, ProgressMonitor progressMonitor) throws OsmTransferException {
     312        if (changeset == null)
     313            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "changeset"));
    289314        try {
    290315            progressMonitor.beginTask((tr("Creating changeset...")));
    291             createPrimitive(changeset, progressMonitor);
    292             this.changeset = changeset;
    293             progressMonitor.setCustomText((tr("Successfully opened changeset {0}",this.changeset.getId())));
     316            initialize(progressMonitor);
     317            String ret = "";
     318            try {
     319                ret = sendRequest("PUT", "changeset/create", toXml(changeset),progressMonitor);
     320                changeset.setId(Long.parseLong(ret.trim()));
     321                changeset.setOpen(true);
     322            } catch(NumberFormatException e){
     323                throw new OsmTransferException(tr("unexpected format of id replied by the server, got ''{0}''", ret));
     324            }
     325            progressMonitor.setCustomText((tr("Successfully opened changeset {0}",changeset.getId())));
    294326        } finally {
    295327            progressMonitor.finishTask();
    … …  
    298330
    299331    /**
    300      * Updates the current changeset with the keys in  <code>changesetUpdate</code>.
    301      *
    302      * @param changesetUpdate the changeset to update
    303      * @param progressMonitor the progress monitor
     332     * Updates a changeset with the keys in  <code>changesetUpdate</code>. The changeset must not
     333     * be null and id > 0 must be true.
     334     *
     335     * @param changeset the changeset to update. Must not be null.
     336     * @param monitor the progress monitor. If null, uses the {@see NullProgressMonitor#INSTANCE}.
    304337     *
    305338     * @throws OsmTransferException if something goes wrong.
    306      */
    307     public void updateChangeset(Changeset changesetUpdate, ProgressMonitor progressMonitor) throws OsmTransferException {
     339     * @throws IllegalArgumentException if changeset is null
     340     * @throws IllegalArgumentException if changeset.getId() == 0
     341     *
     342     */
     343    public void updateChangeset(Changeset changeset, ProgressMonitor monitor) throws OsmTransferException {
     344        if (changeset == null)
     345            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "changeset"));
     346        if (monitor == null) {
     347            monitor = NullProgressMonitor.INSTANCE;
     348        }
     349        if (changeset.getId() <= 0)
     350            throw new IllegalArgumentException(tr("id of changeset > 0 required. Got {0}", changeset.getId()));
    308351        try {
    309             progressMonitor.beginTask(tr("Updating changeset..."));
    310             initialize(progressMonitor);
    311             if (this.changeset != null && this.changeset.getId() > 0) {
    312                 if (this.changeset.hasEqualSemanticAttributes(changesetUpdate)) {
    313                     progressMonitor.setCustomText(tr("Changeset {0} is unchanged. Skipping update.", changesetUpdate.getId()));
    314                     return;
    315                 }
    316                 this.changeset.setKeys(changesetUpdate.getKeys());
    317                 progressMonitor.setCustomText(tr("Updating changeset {0}...", this.changeset.getId()));
    318                 sendRequest(
    319                         "PUT",
    320                         OsmPrimitiveType.from(changesetUpdate).getAPIName() + "/" + this.changeset.getId(),
    321                         toXml(this.changeset, true),
    322                         progressMonitor
    323                 );
    324             } else
    325                 throw new OsmTransferException(tr("Failed to update changeset. Either there is no current changeset or the id of the current changeset is 0"));
     352            monitor.beginTask(tr("Updating changeset..."));
     353            initialize(monitor);
     354            monitor.setCustomText(tr("Updating changeset {0}...", changeset.getId()));
     355            sendRequest(
     356                    "PUT",
     357                    "changeset/" + this.changeset.getId(),
     358                    toXml(this.changeset),
     359                    monitor
     360            );
    326361        } finally {
    327             progressMonitor.finishTask();
    328         }
    329     }
    330 
    331     /**
    332      * Closes a changeset on the server.
    333      *
    334      * @param changesetProcessingType how changesets are currently handled
    335      * @param progressMonitor the progress monitor
     362            monitor.finishTask();
     363        }
     364    }
     365
     366
     367    /**
     368     * Closes a changeset on the server. Sets changeset.setOpen(false) if this operation
     369     * succeeds.
     370     *
     371     * @param changeset the changeset to be closed. Must not be null. changeset.getId() > 0 required.
     372     * @param monitor the progress monitor. If null, uses {@see NullProgressMonitor#INSTANCE}
    336373     *
    337374     * @throws OsmTransferException if something goes wrong.
    338      */
    339     public void stopChangeset(ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
    340         if (changesetProcessingType == null) {
    341             changesetProcessingType = ChangesetProcessingType.USE_NEW_AND_CLOSE;
    342         }
     375     * @throws IllegalArgumentException thrown if changeset is null
     376     * @throws IllegalArgumentException thrown if changeset.getId() <= 0
     377     */
     378    public void closeChangeset(Changeset changeset, ProgressMonitor monitor) throws OsmTransferException {
     379        if (changeset == null)
     380            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "changeset"));
     381        if (monitor == null) {
     382            monitor = NullProgressMonitor.INSTANCE;
     383        }
     384        if (changeset.getId() <= 0)
     385            throw new IllegalArgumentException(tr("id of changeset > 0 required. Got {0}", changeset.getId()));
    343386        try {
    344             progressMonitor.beginTask(tr("Closing changeset..."));
    345             initialize(progressMonitor);
    346             if (changesetProcessingType.isCloseAfterUpload()) {
    347                 progressMonitor.setCustomText(tr("Closing changeset {0}...", changeset.getId()));
    348                 if (this.changeset != null && this.changeset.getId() > 0) {
    349                     sendRequest("PUT", "changeset" + "/" + changeset.getId() + "/close", null, progressMonitor);
    350                     changeset = null;
    351                 }
    352             } else {
    353                 progressMonitor.setCustomText(tr("Leaving changeset {0} open...", changeset.getId()));
    354             }
     387            monitor.beginTask(tr("Closing changeset..."));
     388            initialize(monitor);
     389            sendRequest("PUT", "changeset" + "/" + changeset.getId() + "/close", null, monitor);
     390            changeset.setOpen(false);
    355391        } finally {
    356             progressMonitor.finishTask();
     392            monitor.finishTask();
    357393        }
    358394    }
    … …  
    365401     * @throws OsmTransferException if something is wrong
    366402     */
    367     public Collection<OsmPrimitive> uploadDiff(final Collection<OsmPrimitive> list, ProgressMonitor progressMonitor) throws OsmTransferException {
    368 
    369         progressMonitor.beginTask("", list.size() * 2);
     403    public Collection<OsmPrimitive> uploadDiff(Collection<OsmPrimitive> list, ProgressMonitor progressMonitor) throws OsmTransferException {
    370404        try {
     405            progressMonitor.beginTask("", list.size() * 2);
    371406            if (changeset == null)
    372407                throw new OsmTransferException(tr("No changeset present for diff upload"));
    … …  
    385420
    386421            String diff = duv.getDocument();
    387             try {
    388                 String diffresult = sendRequest("POST", "changeset/" + changeset.getId() + "/upload", diff,progressMonitor);
    389                 DiffResultReader.parseDiffResult(diffresult, list, processed, duv.getNewIdMap(),
    390                         progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
    391             } catch(OsmTransferException e) {
    392                 throw e;
    393             } catch(Exception e) {
    394                 throw new OsmTransferException(e);
    395             }
    396 
     422            String diffresult = sendRequest("POST", "changeset/" + changeset.getId() + "/upload", diff,progressMonitor);
     423            DiffResultReader.parseDiffResult(diffresult, list, processed, duv.getNewIdMap(),
     424                    progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
    397425            return processed;
     426        } catch(OsmTransferException e) {
     427            throw e;
     428        } catch(Exception e) {
     429            throw new OsmTransferException(e);
    398430        } finally {
    399431            progressMonitor.finishTask();
    … …  
    536568                }
    537569                throw new OsmTransferException(e);
     570            } catch(OsmTransferException e) {
     571                throw e;
    538572            } catch (Exception e) {
    539                 if (e instanceof OsmTransferException) throw (OsmTransferException) e;
    540573                throw new OsmTransferException(e);
    541574            }
    … …  
    552585    }
    553586
    554     /**
    555      * Replies the current changeset
    556      *
    557      * @return the current changeset
    558      */
    559     public Changeset getCurrentChangeset() {
     587
     588    /**
     589     * Ensures that the current changeset can be used for uploading data
     590     *
     591     * @throws OsmTransferException thrown if the current changeset can't be used for
     592     * uploading data
     593     */
     594    protected void ensureValidChangeset() throws OsmTransferException {
     595        if (changeset == null)
     596            throw new OsmTransferException(tr("current changeset is null. Can't upload data."));
     597        if (changeset.getId() <= 0)
     598            throw new OsmTransferException(tr("id of current changeset > required. Current id is {0}", changeset.getId()));
     599    }
     600    /**
     601     * Replies the changeset data uploads are currently directed to
     602     *
     603     * @return the changeset data uploads are currently directed to
     604     */
     605    public Changeset getChangeset() {
    560606        return changeset;
    561607    }
     608
     609    /**
     610     * Sets the changesets to which further data uploads are directed. The changeset
     611     * can be null. If it isn't null it must have been created, i.e. id > 0 is required. Furthermore,
     612     * it must be open.
     613     *
     614     * @param changeset the changeset
     615     * @throws IllegalArgumentException thrown if changeset.getId() <= 0
     616     * @throws IllegalArgumentException thrown if !changeset.isOpen()
     617     */
     618    public void setChangeset(Changeset changeset) {
     619        if (changeset == null) {
     620            this.changeset = null;
     621            return;
     622        }
     623        if (changeset.getId() <= 0)
     624            throw new IllegalArgumentException(tr("Changeset id > 0 expected. Got {0}", changeset.getId()));
     625        if (!changeset.isOpen())
     626            throw new IllegalArgumentException(tr("Open changeset expected. Got closed changeset with id {0}", changeset.getId()));
     627        this.changeset = changeset;
     628    }
     629
    562630}

  • trunk/src/org/openstreetmap/josm/io/OsmDataParsingException.java

    r2094 r2115  
    77import org.xml.sax.SAXException;
    88
    9 /**
    10  * Represents a parsing error in an OSM data file.
    11  *
    12  * Use {@see #getColumnNumber()} and {@see #getLineNumber()} to locate
    13  * the position in the file where the parsing error occured.
    14  *
    15  */
    169public class OsmDataParsingException extends SAXException {
    1710    private int columnNumber;

  • trunk/src/org/openstreetmap/josm/io/OsmReader.java

    r2094 r2115  
    3636
    3737/**
    38  * Parser for the Osm Api. Read from an input stream and constructs a dataset out of it.
     38 * Parser for the Osm Api. Read from an input stream and construct a dataset out of it.
    3939 *
    4040 */
    … …  
    8080    }
    8181
     82    private static class OsmPrimitiveData {
     83        public long id = 0;
     84        public boolean modified = false;
     85        public boolean deleted = false;
     86        public Date timestamp = new Date();
     87        public User user = null;
     88        public boolean visible = true;
     89        public int version = 0;
     90        public LatLon latlon = new LatLon(0,0);
     91        private OsmPrimitive primitive;
     92
     93        public void copyTo(OsmPrimitive osm) {
     94            osm.setModified(modified);
     95            osm.setDeleted(deleted);
     96            //  id < 0 possible if read from a file
     97            if (id <= 0) {
     98                osm.clearOsmId();
     99            } else {
     100                osm.setOsmId(id, version);
     101            }
     102            osm.setTimestamp(timestamp);
     103            osm.user = user;
     104            osm.setVisible(visible);
     105            osm.mappaintStyle = null;
     106        }
     107
     108        public Node createNode() {
     109            Node node = new Node();
     110            node.setCoor(latlon);
     111            copyTo(node);
     112            primitive = node;
     113            return node;
     114        }
     115
     116        public Way createWay() {
     117            Way way = new Way();
     118            copyTo(way);
     119            primitive = way;
     120            return way;
     121        }
     122        public Relation createRelation() {
     123            Relation relation= new Relation();
     124            copyTo(relation);
     125            primitive = relation;
     126            return relation;
     127        }
     128
     129        public void rememberTag(String key, String value) {
     130            primitive.put(key, value);
     131        }
     132    }
    82133
    83134    /**
    … …  
    100151     */
    101152    private Map<Long, Collection<RelationMemberData>> relations = new HashMap<Long, Collection<RelationMemberData>>();
    102 
    103153
    104154    private class Parser extends DefaultHandler {
    … …  
    241291                current.rememberTag(key, value);
    242292            } else {
    243                 System.out.println(tr("Warning: Undefined element ''{0}'' found in input stream. Skipping.", qName));
     293                throwException(tr("Undefined element ''{0}'' found in input stream. Aborting.", qName));
    244294            }
    245295        }
    … …  
    503553        }
    504554    }
    505 
    506     /**
    507      * Temporarily holds data for a parsed {@see OsmPrimitive} and provides
    508      * methods for creating an {@see OsmPrimitive} based on this data.
    509      */
    510     private static class OsmPrimitiveData {
    511         public long id = 0;
    512         public boolean modified = false;
    513         public boolean deleted = false;
    514         public Date timestamp = new Date();
    515         public User user = null;
    516         public boolean visible = true;
    517         public int version = 0;
    518         public LatLon latlon = new LatLon(0,0);
    519         private OsmPrimitive primitive;
    520 
    521         public void copyTo(OsmPrimitive osm) {
    522             //  id < 0 possible if read from a file
    523             if (id <= 0) {
    524                 osm.clearOsmId();
    525             } else {
    526                 osm.setOsmId(id, version);
    527             }
    528             osm.setDeleted(deleted);
    529             osm.setModified(modified);
    530             osm.setTimestamp(timestamp);
    531             osm.user = user;
    532             osm.setVisible(visible);
    533             osm.mappaintStyle = null;
    534         }
    535 
    536         public Node createNode() {
    537             Node node = new Node();
    538             node.setCoor(latlon);
    539             copyTo(node);
    540             primitive = node;
    541             return node;
    542         }
    543 
    544         public Way createWay() {
    545             Way way = new Way();
    546             copyTo(way);
    547             primitive = way;
    548             return way;
    549         }
    550         public Relation createRelation() {
    551             Relation relation= new Relation();
    552             copyTo(relation);
    553             primitive = relation;
    554             return relation;
    555         }
    556 
    557         public void rememberTag(String key, String value) {
    558             primitive.put(key, value);
    559         }
    560     }
    561555}

  • trunk/src/org/openstreetmap/josm/io/OsmServerWriter.java

    r2081 r2115  
    6565     *
    6666     * @param primitives the collection of primitives to upload
    67      * @param changeset the changeset to be used if <code>changesetProcessingType</code> indicates that
    68      *   a new changeset should be opened
    69      * @param changesetProcessingType how we handle changesets
    7067     * @param progressMonitor the progress monitor
    7168     * @throws OsmTransferException thrown if an exception occurs
    7269     */
    73     protected void uploadChangesIndividually(Collection<OsmPrimitive> primitives, Changeset changeset, ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
     70    protected void uploadChangesIndividually(Collection<OsmPrimitive> primitives, ProgressMonitor progressMonitor) throws OsmTransferException {
    7471        try {
    7572            progressMonitor.beginTask(tr("Starting to upload with one request per primitive ..."));
    7673            progressMonitor.setTicksCount(primitives.size());
    77             if (changesetProcessingType.isUseNew()) {
    78                 api.createChangeset(changeset,progressMonitor.createSubTaskMonitor(0, false));
    79             } else {
    80                 api.updateChangeset(changeset,progressMonitor.createSubTaskMonitor(0, false));
    81             }
    8274            uploadStartTime = System.currentTimeMillis();
    8375            for (OsmPrimitive osm : primitives) {
    … …  
    8678                String msg = "";
    8779                switch(OsmPrimitiveType.from(osm)) {
    88                 case NODE: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading node ''{4}'' (id: {5})"); break;
    89                 case WAY: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading way ''{4}'' (id: {5})"); break;
    90                 case RELATION: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading relation ''{4}'' (id: {5})"); break;
     80                    case NODE: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading node ''{4}'' (id: {5})"); break;
     81                    case WAY: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading way ''{4}'' (id: {5})"); break;
     82                    case RELATION: msg = marktr("{0}% ({1}/{2}), {3} left. Uploading relation ''{4}'' (id: {5})"); break;
    9183                }
    9284                progressMonitor.subTask(
    … …  
    10799            throw new OsmTransferException(e);
    108100        } finally {
    109             try {
    110                 // starting the changeset may have failed, for instance because the user
    111                 // cancelled the upload task. Only close the changeset if we currently have
    112                 // an open changeset
    113 
    114                 if (api.getCurrentChangeset() != null && api.getCurrentChangeset().getId() > 0) {
    115                     api.stopChangeset(changesetProcessingType, progressMonitor.createSubTaskMonitor(0, false));
    116                 }
    117             } catch(Exception e) {
    118                 OsmChangesetCloseException closeException = new OsmChangesetCloseException(e);
    119                 closeException.setChangeset(api.getCurrentChangeset());
    120                 throw closeException;
    121             } finally {
    122                 progressMonitor.finishTask();
    123             }
     101            progressMonitor.finishTask();
    124102        }
    125103    }
    … …  
    132110     * @throws OsmTransferException thrown if an exception occurs
    133111     */
    134     protected void uploadChangesAsDiffUpload(Collection<OsmPrimitive> primitives, Changeset changeset, ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
     112    protected void uploadChangesAsDiffUpload(Collection<OsmPrimitive> primitives, ProgressMonitor progressMonitor) throws OsmTransferException {
    135113        // upload everything in one changeset
    136114        //
    137115        try {
    138116            progressMonitor.beginTask(tr("Starting to upload in one request ..."));
    139             if (changesetProcessingType.isUseNew()) {
    140                 api.createChangeset(changeset,progressMonitor.createSubTaskMonitor(0, false));
    141             } else {
    142                 api.updateChangeset(changeset,progressMonitor.createSubTaskMonitor(0, false));
    143             }
    144117            processed.addAll(api.uploadDiff(primitives, progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false)));
    145118        } catch(OsmTransferException e) {
    … …  
    148121            throw new OsmTransferException(e);
    149122        } finally {
    150             try {
    151                 api.stopChangeset(changesetProcessingType, progressMonitor.createSubTaskMonitor(0, false));
    152             } catch (Exception ee) {
    153                 OsmChangesetCloseException closeException = new OsmChangesetCloseException(ee);
    154                 closeException.setChangeset(api.getCurrentChangeset());
    155                 throw closeException;
    156             } finally {
    157                 progressMonitor.finishTask();
    158             }
    159 
     123            progressMonitor.finishTask();
    160124        }
    161125    }
    … …  
    167131     * @param primitives list of objects to send
    168132     */
    169     public void uploadOsm(String apiVersion, Collection<OsmPrimitive> primitives, Changeset changeset, ChangesetProcessingType changesetProcessingType, ProgressMonitor progressMonitor) throws OsmTransferException {
     133    public void uploadOsm(String apiVersion, Collection<OsmPrimitive> primitives, Changeset changeset, boolean closeChangesetAfterUpload, ProgressMonitor progressMonitor) throws OsmTransferException {
    170134        processed = new LinkedList<OsmPrimitive>();
    171135        progressMonitor.beginTask(tr("Uploading data ..."));
    … …  
    184148                useDiffUpload = false;
    185149            }
    186 
     150            if (changeset == null) {
     151                changeset = new Changeset();
     152            }
     153            if (changeset.getId() == 0) {
     154                api.openChangeset(changeset,progressMonitor.createSubTaskMonitor(0, false));
     155            } else {
     156                api.updateChangeset(changeset,progressMonitor.createSubTaskMonitor(0, false));
     157            }
     158            api.setChangeset(changeset);
    187159            if (useDiffUpload) {
    188                 uploadChangesAsDiffUpload(primitives,changeset, changesetProcessingType, progressMonitor.createSubTaskMonitor(0,false));
     160                uploadChangesAsDiffUpload(primitives,progressMonitor.createSubTaskMonitor(0,false));
    189161            } else {
    190                 uploadChangesIndividually(primitives,changeset,changesetProcessingType,  progressMonitor.createSubTaskMonitor(0,false));
    191             }
     162                uploadChangesIndividually(primitives,progressMonitor.createSubTaskMonitor(0,false));
     163            }
     164        } catch(OsmTransferException e) {
     165            throw e;
     166        } catch(Exception e) {
     167            throw new OsmTransferException(e);
    192168        } finally {
    193             progressMonitor.finishTask();
     169            try {
     170                if (closeChangesetAfterUpload && api.getChangeset() != null && api.getChangeset().getId() > 0) {
     171                    api.closeChangeset(changeset,progressMonitor.createSubTaskMonitor(0, false));
     172                    api.setChangeset(null);
     173                }
     174            } catch (Exception ee) {
     175                OsmChangesetCloseException closeException = new OsmChangesetCloseException(ee);
     176                closeException.setChangeset(api.getChangeset());
     177                throw closeException;
     178            } finally {
     179                progressMonitor.finishTask();
     180            }
    194181        }
    195182    }

  • trunk/src/org/openstreetmap/josm/io/OsmWriter.java

    r2070 r2115  
    66import java.util.Map.Entry;
    77
     8import org.openstreetmap.josm.data.coor.CoordinateFormat;
    89import org.openstreetmap.josm.data.osm.Changeset;
    910import org.openstreetmap.josm.data.osm.DataSet;
    … …  
    1415import org.openstreetmap.josm.data.osm.Relation;
    1516import org.openstreetmap.josm.data.osm.RelationMember;
    16 import org.openstreetmap.josm.data.osm.User;
     17import org.openstreetmap.josm.data.osm.Tagged;
    1718import org.openstreetmap.josm.data.osm.Way;
    1819import org.openstreetmap.josm.data.osm.visitor.Visitor;
    … …  
    143144
    144145    public void visit(Changeset cs) {
    145         addCommon(cs, "changeset");
    146         out.println(">\n");
    147         addTags(cs, "changeset", false);
    148     }
    149 
    150     public final void footer(PrintWriter out) {
    151         out.println("</osm>");
     146        out.print("  <changeset ");
     147        out.print(" id='"+cs.getId()+"'");
     148        if (cs.getUser() != null) {
     149            out.print(" user='"+cs.getUser().getName() +"'");
     150            out.print(" uid='"+cs.getUser().getId() +"'");
     151        }
     152        if (cs.getCreatedAt() != null) {
     153            out.print(" created_at='"+DateUtils.fromDate(cs.getCreatedAt()) +"'");
     154        }
     155        if (cs.getClosedAt() != null) {
     156            out.print(" closed_at='"+DateUtils.fromDate(cs.getClosedAt()) +"'");
     157        }
     158        out.print(" open='"+ (cs.isOpen() ? "true" : "false") +"'");
     159        if (cs.getMin() != null) {
     160            out.print(" min_lon='"+ cs.getMin().lonToString(CoordinateFormat.DECIMAL_DEGREES) +"'");
     161            out.print(" min_lat='"+ cs.getMin().latToString(CoordinateFormat.DECIMAL_DEGREES) +"'");
     162        }
     163        if (cs.getMax() != null) {
     164            out.print(" max_lon='"+ cs.getMin().lonToString(CoordinateFormat.DECIMAL_DEGREES) +"'");
     165            out.print(" max_lat='"+ cs.getMin().latToString(CoordinateFormat.DECIMAL_DEGREES) +"'");
     166        }
     167        out.println(">");
     168        addTags(cs, "changeset", false); // also writes closing </changeset>
    152169    }
    153170
    … …  
    164181    }
    165182
    166     private void addTags(OsmPrimitive osm, String tagname, boolean tagOpen) {
     183    private void addTags(Tagged osm, String tagname, boolean tagOpen) {
    167184        if (osm.hasKeys()) {
    168185            if (tagOpen) {
    169186                out.println(">");
    170187            }
    171             for (Entry<String, String> e : osm.entrySet()) {
     188            for (Entry<String, String> e : osm.getKeys().entrySet()) {
    172189                if ((osm instanceof Changeset) || !("created_by".equals(e.getKey()))) {
    173190                    out.println("    <tag k='"+ XmlWriter.encode(e.getKey()) +
Note: See TracChangeset for help on using the changeset viewer.