Changeset 4310 in josm


Ignore:
Timestamp:
2011-08-11T00:26:21+02:00 (8 years ago)
Author:
stoecker
Message:

fix #6680, fix #6677 - i18n issues

Location:
trunk/src/org/openstreetmap/josm
Files:
70 edited
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/CloseChangesetAction.java

    r3083 r4310  
    7575    private class DownloadOpenChangesetsTask extends PleaseWaitRunnable {
    7676
    77         private boolean cancelled;
     77        private boolean canceled;
    7878        private OsmServerChangesetReader reader;
    7979        private List<Changeset> changesets;
     
    9292        @Override
    9393        protected void cancel() {
    94             this.cancelled = true;
     94            this.canceled = true;
    9595            reader.cancel();
    9696        }
     
    105105                            }
    106106                            ChangesetCache.getInstance().update(changesets);
    107                             if (!cancelled && lastException == null) {
     107                            if (!canceled && lastException == null) {
    108108                                onPostDownloadOpenChangesets();
    109109                            }
     
    129129            try {
    130130                userInfo = fetchUserInfo();
    131                 if (cancelled)
     131                if (canceled)
    132132                    return;
    133133                reader = new OsmServerChangesetReader();
     
    138138                );
    139139            } catch(Exception e) {
    140                 if (cancelled)
     140                if (canceled)
    141141                    return;
    142142                lastException = e;
     
    144144        }
    145145
    146         public boolean isCancelled() {
    147             return cancelled;
     146        public boolean isCanceled() {
     147            return canceled;
    148148        }
    149149
  • trunk/src/org/openstreetmap/josm/actions/CombineWayAction.java

    r3510 r4310  
    226226        if (!completeWayTags.isApplicableToPrimitive() || !parentRelations.isEmpty()) {
    227227            dialog.setVisible(true);
    228             if (dialog.isCancelled())
     228            if (dialog.isCanceled())
    229229                throw new UserCancelException();
    230230        }
  • trunk/src/org/openstreetmap/josm/actions/JoinAreasAction.java

    r4045 r4310  
    366366        if (!resolveTagConflicts(areas))
    367367            return;
    368         //user cancelled, do nothing.
     368        //user canceled, do nothing.
    369369
    370370        try {
     
    570570        if (!completeWayTags.isApplicableToPrimitive() || !parentRelations.isEmpty()) {
    571571            dialog.setVisible(true);
    572             if (dialog.isCancelled())
     572            if (dialog.isCanceled())
    573573                return false;
    574574        }
  • trunk/src/org/openstreetmap/josm/actions/MergeNodesAction.java

    r4045 r4310  
    248248        if (! nodeTags.isApplicableToPrimitive() || relationToNodeReferences.size() > 1) {
    249249            dialog.setVisible(true);
    250             if (dialog.isCancelled())
     250            if (dialog.isCanceled())
    251251                return null;
    252252        }
  • trunk/src/org/openstreetmap/josm/actions/OpenFileAction.java

    r4247 r4310  
    8787        private List<File> successfullyOpenedFiles = new ArrayList<File>();
    8888        private FileFilter fileFilter;
    89         private boolean cancelled;
     89        private boolean canceled;
    9090        private boolean recordHistory = false;
    9191
     
    114114        @Override
    115115        protected void cancel() {
    116             this.cancelled = true;
     116            this.canceled = true;
    117117        }
    118118
     
    291291        public void importData(FileImporter importer, List<File> files) {
    292292            if (importer.isBatchImporter()) {
    293                 if (cancelled) return;
     293                if (canceled) return;
    294294                String msg;
    295295                if (files.size() == 1) {
     
    305305            } else {
    306306                for (File f : files) {
    307                     if (cancelled) return;
     307                    if (canceled) return;
    308308                    getProgressMonitor().indeterminateSubTask(tr("Opening file ''{0}'' ...", f.getAbsolutePath()));
    309309                    if (importer.importDataHandleExceptions(f, getProgressMonitor().createSubTaskMonitor(1, false))) {
  • trunk/src/org/openstreetmap/josm/actions/OpenLocationAction.java

    r4045 r4310  
    7777        gc.anchor = GridBagConstraints.FIRST_LINE_START;
    7878        all.add(new JLabel(tr("Enter URL to download:")), gc);
    79         HistoryComboBox uploadAdresses = new HistoryComboBox();
    80         uploadAdresses.setToolTipText(tr("Enter an URL from where data should be downloaded"));
    81         restoreUploadAddressHistory(uploadAdresses);
     79        HistoryComboBox uploadAddresses = new HistoryComboBox();
     80        uploadAddresses.setToolTipText(tr("Enter an URL from where data should be downloaded"));
     81        restoreUploadAddressHistory(uploadAddresses);
    8282        gc.gridy = 1;
    83         all.add(uploadAdresses, gc);
     83        all.add(uploadAddresses, gc);
    8484        gc.gridy = 2;
    8585        gc.fill = GridBagConstraints.BOTH;
     
    9999        dialog.showDialog();
    100100        if (dialog.getValue() != 1) return;
    101         remindUploadAddressHistory(uploadAdresses);
    102         openUrl(layer.isSelected(), uploadAdresses.getText());
     101        remindUploadAddressHistory(uploadAddresses);
     102        openUrl(layer.isSelected(), uploadAddresses.getText());
    103103    }
    104104
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadOsmTask.java

    r4191 r4310  
    2121import org.openstreetmap.josm.io.OsmServerLocationReader;
    2222import org.openstreetmap.josm.io.OsmServerReader;
    23 import org.openstreetmap.josm.io.OsmTransferCancelledException;
     23import org.openstreetmap.josm.io.OsmTransferCanceledException;
    2424import org.openstreetmap.josm.io.OsmTransferException;
    2525import org.xml.sax.SAXException;
     
    8989            } catch(Exception e) {
    9090                if (isCanceled()) {
    91                     System.out.println(tr("Ignoring exception because download has been cancelled. Exception was: {0}", e.toString()));
     91                    System.out.println(tr("Ignoring exception because download has been canceled. Exception was: {0}", e.toString()));
    9292                    return;
    9393                }
    94                 if (e instanceof OsmTransferCancelledException) {
     94                if (e instanceof OsmTransferCanceledException) {
    9595                    setCanceled(true);
    9696                    return;
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadReferrersTask.java

    r4094 r4310  
    4141 */
    4242public class DownloadReferrersTask extends PleaseWaitRunnable {
    43     private boolean cancelled;
     43    private boolean canceled;
    4444    private Exception lastException;
    4545    private OsmServerReader reader;
     
    6161        super("Download referrers", false /* don't ignore exception*/);
    6262        CheckParameterUtil.ensureParameterNotNull(targetLayer, "targetLayer");
    63         cancelled = false;
     63        canceled = false;
    6464        this.children = new HashMap<Long, OsmPrimitiveType>();
    6565        if (children != null) {
     
    8585        super("Download referrers", false /* don't ignore exception*/);
    8686        CheckParameterUtil.ensureParameterNotNull(targetLayer, "targetLayer");
    87         cancelled = false;
     87        canceled = false;
    8888        this.children = new HashMap<Long, OsmPrimitiveType>();
    8989        if (children != null) {
     
    115115            throw new IllegalArgumentException(MessageFormat.format("Id > 0 required, got {0}", id));
    116116        CheckParameterUtil.ensureParameterNotNull(type, "type");
    117         cancelled = false;
     117        canceled = false;
    118118        this.children = new HashMap<Long, OsmPrimitiveType>();
    119119        this.children.put(id, type);
     
    136136        if (primitiveId.isNew())
    137137            throw new IllegalArgumentException(MessageFormat.format("Cannot download referrers for new primitives (ID {0})", primitiveId.getUniqueId()));
    138         cancelled = false;
     138        canceled = false;
    139139        this.children = new HashMap<Long, OsmPrimitiveType>();
    140140        this.children.put(primitiveId.getUniqueId(), primitiveId.getType());
     
    145145    @Override
    146146    protected void cancel() {
    147         cancelled = true;
     147        canceled = true;
    148148        synchronized(this) {
    149149            if (reader != null) {
     
    155155    @Override
    156156    protected void finish() {
    157         if (cancelled)
     157        if (canceled)
    158158            return;
    159159        if (lastException != null) {
     
    227227            int i=1;
    228228            for (Entry<Long, OsmPrimitiveType> entry: children.entrySet()) {
    229                 if (cancelled)
     229                if (canceled)
    230230                    return;
    231231                String msg = "";
     
    240240            }
    241241        } catch(Exception e) {
    242             if (cancelled)
     242            if (canceled)
    243243                return;
    244244            lastException = e;
  • trunk/src/org/openstreetmap/josm/actions/upload/ApiPreconditionCheckerHook.java

    r3719 r4310  
    1717import org.openstreetmap.josm.io.OsmApi;
    1818import org.openstreetmap.josm.io.OsmApiInitializationException;
    19 import org.openstreetmap.josm.io.OsmTransferCancelledException;
     19import org.openstreetmap.josm.io.OsmTransferCanceledException;
    2020
    2121public class ApiPreconditionCheckerHook implements UploadHook {
     
    3939                    return false;
    4040            }
    41         } catch(OsmTransferCancelledException e){
     41        } catch(OsmTransferCanceledException e){
    4242            return false;
    4343        } catch (OsmApiInitializationException e) {
  • trunk/src/org/openstreetmap/josm/actions/upload/ValidateUploadHook.java

    r4097 r4310  
    133133
    134134        ExtendedDialog ed = new ExtendedDialog(Main.parent,
    135                 tr("Supicious data found. Upload anyway?"),
     135                tr("Suspicious data found. Upload anyway?"),
    136136                new String[] {tr("Continue upload"), tr("Cancel")});
    137137        ed.setButtonIcons(new String[] {"ok.png", "cancel.png"});
  • trunk/src/org/openstreetmap/josm/data/Preferences.java

    r4243 r4310  
    529529            } catch(IOException e1) {
    530530                e1.printStackTrace();
    531                 System.err.println(tr("Warning: Failed to initialize preferences.Failed to reset preference file to default: {0}", getPreferenceFile()));
     531                System.err.println(tr("Warning: Failed to initialize preferences. Failed to reset preference file to default: {0}", getPreferenceFile()));
    532532            }
    533533        }
  • trunk/src/org/openstreetmap/josm/data/Version.java

    r4259 r4310  
    110110            } catch(NumberFormatException e) {
    111111                version = 0;
    112                 System.err.println(tr("Warning: unexpected JOSM version number in revison file, value is ''{0}''", value));
     112                System.err.println(tr("Warning: unexpected JOSM version number in revision file, value is ''{0}''", value));
    113113            }
    114114        } else {
  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r4126 r4310  
    736736        if (result == null) {
    737737            System.out.println(tr("JOSM expected to find primitive [{0} {1}] in dataset but it is not there. Please report this "
    738                     + " at http://josm.openstreetmap.de . This is not a critical error, it should be safe to continue in your work.",
     738                    + "at http://josm.openstreetmap.de/. This is not a critical error, it should be safe to continue in your work.",
    739739                    primitiveId.getType(), Long.toString(primitiveId.getUniqueId())));
    740740            new Exception().printStackTrace();
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/MapRendererFactory.java

    r4196 r4310  
    3939public class MapRendererFactory {
    4040
    41     /** preference key for the the renderer class name. Default: class name for {@link StyledMapRenderer}
     41    /** preference key for the renderer class name. Default: class name for {@link StyledMapRenderer}
    4242     *
    4343     */
  • trunk/src/org/openstreetmap/josm/data/validation/Test.java

    r4059 r4310  
    217217    }
    218218
    219     public boolean isCancelled() {
    220         return progressMonitor.isCancelled();
     219    public boolean isCanceled() {
     220        return progressMonitor.isCanceled();
    221221    }
    222222}
  • trunk/src/org/openstreetmap/josm/data/validation/tests/UnconnectedWays.java

    r4073 r4310  
    102102                    map.put(en, s.w);
    103103                }
    104                 if(isCancelled())
     104                if(isCanceled())
    105105                    return;
    106106            }
     
    114114        map.clear();
    115115        for (MyWaySegment s : ways) {
    116             if(isCancelled())
     116            if(isCanceled())
    117117                return;
    118118            for (Node en : s.nearbyNodes(mindist)) {
     
    134134            map.clear();
    135135            for (MyWaySegment s : ways) {
    136                 if(isCancelled())
     136                if(isCanceled())
    137137                    return;
    138138                for (Node en : s.nearbyNodes(minmiddledist)) {
     
    154154            for (MyWaySegment s : ways) {
    155155                for (Node en : s.nearbyNodes(minmiddledist)) {
    156                     if(isCancelled())
     156                    if(isCanceled())
    157157                        return;
    158158                    if (!othernodes.contains(en)) {
  • trunk/src/org/openstreetmap/josm/gui/PleaseWaitRunnable.java

    r4191 r4310  
    2323 */
    2424public abstract class PleaseWaitRunnable implements Runnable, CancelListener {
    25     private boolean cancelled = false;
     25    private boolean canceled = false;
    2626    private boolean ignoreException;
    2727    private final String title;
     
    113113
    114114    public final void run() {
    115         if (cancelled)
     115        if (canceled)
    116116            return; // since realRun isn't executed, do not call to finish
    117117
  • trunk/src/org/openstreetmap/josm/gui/bbox/TileSelectionBBoxChooser.java

    r3720 r4310  
    435435            HtmlPanel msg = new HtmlPanel();
    436436            msg.setText(tr("<html>Alternatively you may enter a <strong>tile address</strong> for a single tile "
    437                     + "in the format <i>zoomlevel/x/y</i>, i.e. <i>15/256/223</i>. Tile adresses "
     437                    + "in the format <i>zoomlevel/x/y</i>, i.e. <i>15/256/223</i>. Tile addresses "
    438438                    + "in the format <i>zoom,x,y</i> or <i>zoom;x;y</i> are valid too.</html>"));
    439439            pnl.add(msg);
  • trunk/src/org/openstreetmap/josm/gui/conflict/pair/ListMerger.java

    r4191 r4310  
    284284        gc.gridy = 0;
    285285        lblMergedVersion = new JLabel(tr("Merged version"));
    286         lblMergedVersion.setToolTipText(tr("List of merged elements. They will replace the my elements when the merge decisions are applied."));
     286        lblMergedVersion.setToolTipText(tr("List of merged elements. They will replace the list of my elements when the merge decisions are applied."));
    287287        add(lblMergedVersion, gc);
    288288
  • trunk/src/org/openstreetmap/josm/gui/conflict/pair/properties/PropertiesMergeModel.java

    r4116 r4310  
    2323/**
    2424 * This is the model for resolving conflicts in the properties of the
    25  * {@see OsmPrimitive}s. In particular, it represents conflicts in the coordiates of {@see Node}s and
     25 * {@see OsmPrimitive}s. In particular, it represents conflicts in the coordinates of {@see Node}s and
    2626 * the deleted or visible state of {@see OsmPrimitive}s.
    2727 *
  • trunk/src/org/openstreetmap/josm/gui/conflict/pair/properties/PropertiesMerger.java

    r4162 r4310  
    394394        public KeepMyCoordinatesAction() {
    395395            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs/conflict", "tagkeepmine"));
    396             putValue(Action.SHORT_DESCRIPTION, tr("Keep my coordiates"));
     396            putValue(Action.SHORT_DESCRIPTION, tr("Keep my coordinates"));
    397397        }
    398398
     
    409409        public KeepTheirCoordinatesAction() {
    410410            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs/conflict", "tagkeeptheir"));
    411             putValue(Action.SHORT_DESCRIPTION, tr("Keep their coordiates"));
     411            putValue(Action.SHORT_DESCRIPTION, tr("Keep their coordinates"));
    412412        }
    413413
  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/CombinePrimitiveResolverDialog.java

    r3719 r4310  
    6666 * merged to, see {@see #setTargetPrimitive(OsmPrimitive)}.
    6767 *
    68  * After the dialog is closed use {@see #isCancelled()} to check whether the user canceled
     68 * After the dialog is closed use {@see #isCanceled()} to check whether the user canceled
    6969 * the dialog. If it wasn't canceled you may build a collection of {@see Command} objects
    7070 * which reflect the conflict resolution decisions the user made in the dialog:
     
    9393    private TagConflictResolver pnlTagConflictResolver;
    9494    private RelationMemberConflictResolver pnlRelationMemberConflictResolver;
    95     private boolean cancelled;
     95    private boolean canceled;
    9696    private JPanel pnlButtons;
    9797    private OsmPrimitive targetPrimitive;
     
    318318    }
    319319
    320     protected void setCancelled(boolean cancelled) {
    321         this.cancelled = cancelled;
    322     }
    323 
    324     public boolean isCancelled() {
    325         return cancelled;
     320    protected void setCanceled(boolean canceled) {
     321        this.canceled = canceled;
     322    }
     323
     324    public boolean isCanceled() {
     325        return canceled;
    326326    }
    327327
     
    332332            new WindowGeometry(getClass().getName() + ".geometry", WindowGeometry.centerInWindow(Main.parent,
    333333                    new Dimension(600, 400))).applySafe(this);
    334             setCancelled(false);
     334            setCanceled(false);
    335335            btnApply.requestFocusInWindow();
    336336        } else {
     
    350350
    351351        public void actionPerformed(ActionEvent arg0) {
    352             setCancelled(true);
     352            setCanceled(true);
    353353            setVisible(false);
    354354        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDialog.java

    r4157 r4310  
    329329        if (s instanceof MapCSSStyleSource)
    330330            return tr("mapcss");
    331         return tr("unkown");
     331        return tr("unknown");
    332332    }
    333333
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetContentDownloadTask.java

    r3083 r4310  
    2020import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2121import org.openstreetmap.josm.io.OsmServerChangesetReader;
    22 import org.openstreetmap.josm.io.OsmTransferCancelledException;
     22import org.openstreetmap.josm.io.OsmTransferCanceledException;
    2323import org.openstreetmap.josm.io.OsmTransferException;
    2424import org.xml.sax.SAXException;
     
    186186                getProgressMonitor().worked(1);
    187187            }
    188         } catch(OsmTransferCancelledException e) {
    189             // the download was cancelled by the user. This exception is caught if the
     188        } catch(OsmTransferCanceledException e) {
     189            // the download was canceled by the user. This exception is caught if the
    190190            // user canceled the authentication dialog.
    191191            //
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetHeaderDownloadTask.java

    r3083 r4310  
    182182        } catch(OsmTransferException e) {
    183183            if (canceled)
    184                 // ignore exception if cancelled
     184                // ignore exception if canceled
    185185                return;
    186186            // remember other exceptions
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/query/ChangesetQueryTask.java

    r3530 r4310  
    2121import org.openstreetmap.josm.io.OsmServerChangesetReader;
    2222import org.openstreetmap.josm.io.OsmServerUserInfoReader;
    23 import org.openstreetmap.josm.io.OsmTransferCancelledException;
     23import org.openstreetmap.josm.io.OsmTransferCanceledException;
    2424import org.openstreetmap.josm.io.OsmTransferException;
    2525import org.openstreetmap.josm.tools.BugReportExceptionHandler;
     
    171171                changesetReader = null;
    172172            }
    173         } catch(OsmTransferCancelledException e) {
     173        } catch(OsmTransferCanceledException e) {
    174174            // thrown if user cancel the authentication dialog
    175175            canceled = true;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ChildRelationBrowser.java

    r4308 r4310  
    278278     */
    279279    class DownloadAllChildrenTask extends PleaseWaitRunnable {
    280         private boolean cancelled;
     280        private boolean canceled;
    281281        private int conflictsCount;
    282282        private Exception lastException;
     
    299299        @Override
    300300        protected void cancel() {
    301             cancelled = true;
     301            canceled = true;
    302302            OsmApi.getOsmApi().cancel();
    303303        }
     
    314314        @Override
    315315        protected void finish() {
    316             if (cancelled)
     316            if (canceled)
    317317                return;
    318318            if (lastException != null) {
     
    391391        protected void realRun() throws SAXException, IOException, OsmTransferException {
    392392            try {
    393                 while(! relationsToDownload.isEmpty() && !cancelled) {
     393                while(! relationsToDownload.isEmpty() && !canceled) {
    394394                    Relation r = relationsToDownload.pop();
    395395                    if (r.isNew()) {
     
    415415                }
    416416            } catch (Exception e) {
    417                 if (cancelled) {
    418                     System.out.println(tr("Warning: Ignoring exception because task was cancelled. Exception: {0}", e
     417                if (canceled) {
     418                    System.out.println(tr("Warning: Ignoring exception because task was canceled. Exception: {0}", e
    419419                            .toString()));
    420420                    return;
     
    429429     */
    430430    class DownloadRelationSetTask extends PleaseWaitRunnable {
    431         private boolean cancelled;
     431        private boolean canceled;
    432432        private int conflictsCount;
    433433        private Exception lastException;
     
    445445        @Override
    446446        protected void cancel() {
    447             cancelled = true;
     447            canceled = true;
    448448            OsmApi.getOsmApi().cancel();
    449449        }
     
    460460        @Override
    461461        protected void finish() {
    462             if (cancelled)
     462            if (canceled)
    463463                return;
    464464            if (lastException != null) {
     
    494494            try {
    495495                Iterator<Relation> it = relations.iterator();
    496                 while(it.hasNext() && !cancelled) {
     496                while(it.hasNext() && !canceled) {
    497497                    Relation r = it.next();
    498498                    if (r.isNew()) {
     
    508508                }
    509509            } catch (Exception e) {
    510                 if (cancelled) {
    511                     System.out.println(tr("Warning: Ignoring exception because task was cancelled. Exception: {0}", e
     510                if (canceled) {
     511                    System.out.println(tr("Warning: Ignoring exception because task was canceled. Exception: {0}", e
    512512                            .toString()));
    513513                    return;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/DownloadRelationMemberTask.java

    r4308 r4310  
    3232 */
    3333public class DownloadRelationMemberTask extends PleaseWaitRunnable {
    34     private boolean cancelled;
     34    private boolean canceled;
    3535    private Exception lastException;
    3636    private final Set<Relation> parents = new HashSet<Relation>();
     
    7272    @Override
    7373    protected void cancel() {
    74         cancelled = true;
     74        canceled = true;
    7575        synchronized(this) {
    7676            if (objectReader != null) {
     
    8383    protected void finish() {
    8484        Main.map.repaint();
    85         if (cancelled)
     85        if (canceled)
    8686            return;
    8787        if (lastException != null) {
     
    105105        } else {
    106106            return trn("Downloading {0} incomplete child of {1} parent relations",
    107                     "Downloading {0} incomplete children of  {1} parent relations",
     107                    "Downloading {0} incomplete children of {1} parent relations",
    108108                    children.size(),
    109109                    children.size(),
     
    116116        try {
    117117            synchronized (this) {
    118                 if (cancelled) return;
     118                if (canceled) return;
    119119                objectReader = new MultiFetchServerObjectReader();
    120120            }
     
    129129            dataSet.deleteInvisible();
    130130            synchronized (this) {
    131                 if (cancelled) return;
     131                if (canceled) return;
    132132                objectReader = null;
    133133            }
     
    143143
    144144        } catch (Exception e) {
    145             if (cancelled) {
    146                 System.out.println(tr("Warning: Ignoring exception because task was cancelled. Exception: {0}", e
     145            if (canceled) {
     146                System.out.println(tr("Warning: Ignoring exception because task was canceled. Exception: {0}", e
    147147                        .toString()));
    148148                return;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/DownloadRelationTask.java

    r4308 r4310  
    2828 */
    2929public class DownloadRelationTask extends PleaseWaitRunnable {
    30     private boolean cancelled;
     30    private boolean canceled;
    3131    private Exception lastException;
    3232    private Collection<Relation> relations;
     
    5252    @Override
    5353    protected void cancel() {
    54         cancelled = true;
     54        canceled = true;
    5555        synchronized(this) {
    5656            if (objectReader != null) {
     
    6262    @Override
    6363    protected void finish() {
    64         if (cancelled)
     64        if (canceled)
    6565            return;
    6666        if (lastException != null) {
     
    7979                getProgressMonitor().setCustomText(tr("({0}/{1}): Downloading relation ''{2}''...", i,relations.size(),relation.getDisplayName(DefaultNameFormatter.getInstance())));
    8080                synchronized (this) {
    81                     if (cancelled) return;
     81                    if (canceled) return;
    8282                    objectReader = new OsmServerObjectReader(relation.getPrimitiveId(), true /* full download */);
    8383                }
     
    8888                    return;
    8989                synchronized (this) {
    90                     if (cancelled) return;
     90                    if (canceled) return;
    9191                    objectReader = null;
    9292                }
     
    106106            );
    107107        } catch (Exception e) {
    108             if (cancelled) {
    109                 System.out.println(tr("Warning: Ignoring exception because task was cancelled. Exception: {0}", e
     108            if (canceled) {
     109                System.out.println(tr("Warning: Ignoring exception because task was canceled. Exception: {0}", e
    110110                        .toString()));
    111111                return;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ParentRelationLoadingTask.java

    r4308 r4310  
    3939 *       new Runnable() {
    4040 *          public void run() {
    41  *              if (task.isCancelled() || task.hasError())
     41 *              if (task.isCanceled() || task.hasError())
    4242 *                  return;
    4343 *              List<Relation> parents = task.getParents();
     
    5252 */
    5353public class ParentRelationLoadingTask extends PleaseWaitRunnable{
    54     private boolean cancelled;
     54    private boolean canceled;
    5555    private Exception lastException;
    5656    private DataSet referrers;
     
    9393
    9494    /**
    95      * Replies true if this has been cancelled by the user.
    96      *
    97      * @return true if this has been cancelled by the user.
    98      */
    99     public boolean isCancelled() {
    100         return cancelled;
     95     * Replies true if this has been canceled by the user.
     96     *
     97     * @return true if this has been canceled by the user.
     98     */
     99    public boolean isCanceled() {
     100        return canceled;
    101101    }
    102102
     
    120120    @Override
    121121    protected void cancel() {
    122         cancelled = true;
     122        canceled = true;
    123123        OsmApi.getOsmApi().cancel();
    124124    }
     
    139139    @Override
    140140    protected void finish() {
    141         if (cancelled) return;
     141        if (canceled) return;
    142142        if (lastException != null) {
    143143            showLastException();
     
    191191            }
    192192        } catch(Exception e) {
    193             if (cancelled) {
    194                 System.out.println(tr("Warning: Ignoring exception because task was cancelled. Exception: {0}", e.toString()));
     193            if (canceled) {
     194                System.out.println(tr("Warning: Ignoring exception because task was canceled. Exception: {0}", e.toString()));
    195195                return;
    196196            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/ReferringRelationsBrowser.java

    r3479 r4310  
    109109                    new Runnable() {
    110110                        public void run() {
    111                             if (task.isCancelled() || task.hasError())
     111                            if (task.isCanceled() || task.hasError())
    112112                                return;
    113113                            model.populate(task.getParents());
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/RelationTree.java

    r4308 r4310  
    102102     */
    103103    class RelationLoader extends PleaseWaitRunnable {
    104         private boolean cancelled;
     104        private boolean canceled;
    105105        private Exception lastException;
    106106        private Relation relation;
     
    122122        protected void cancel() {
    123123            OsmApi.getOsmApi().cancel();
    124             this.cancelled = true;
     124            this.canceled = true;
    125125        }
    126126
    127127        @Override
    128128        protected void finish() {
    129             if (cancelled)
     129            if (canceled)
    130130                return;
    131131            if (lastException != null) {
     
    155155                        .createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
    156156            } catch(Exception e) {
    157                 if (cancelled) {
    158                     System.out.println(tr("Warning: Ignoring exception because task was cancelled. Exception: {0}", e.toString()));
     157                if (canceled) {
     158                    System.out.println(tr("Warning: Ignoring exception because task was canceled. Exception: {0}", e.toString()));
    159159                    return;
    160160                }
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryLoadTask.java

    r3083 r4310  
    4747public class HistoryLoadTask extends PleaseWaitRunnable {
    4848
    49     private boolean cancelled = false;
     49    private boolean canceled = false;
    5050    private Exception lastException  = null;
    5151    private HashSet<PrimitiveId> toLoad;
     
    160160    protected void cancel() {
    161161        OsmApi.getOsmApi().cancel();
    162         cancelled = true;
     162        canceled = true;
    163163    }
    164164
    165165    @Override
    166166    protected void finish() {
    167         if (isCancelled())
     167        if (isCanceled())
    168168            return;
    169169        if (lastException != null) {
     
    179179        try {
    180180            for(PrimitiveId pid: toLoad) {
    181                 if (cancelled) {
     181                if (canceled) {
    182182                    break;
    183183                }
     
    196196                    ds = reader.parseHistory(progressMonitor.createSubTaskMonitor(1, false));
    197197                } catch(OsmTransferException e) {
    198                     if (cancelled)
     198                    if (canceled)
    199199                        return;
    200200                    throw e;
     
    208208    }
    209209
    210     public boolean isCancelled() {
    211         return cancelled;
     210    public boolean isCanceled() {
     211        return canceled;
    212212    }
    213213
  • trunk/src/org/openstreetmap/josm/gui/io/AbstractIOTask.java

    r3083 r4310  
    88public abstract class AbstractIOTask implements Runnable {
    99
    10     /** indicates whether the task has been cancelled */
    11     private boolean cancelled;
     10    /** indicates whether the task has been canceled */
     11    private boolean canceled;
    1212    /** indicates whether the task has been failed */
    1313    private boolean failed;
     
    1616
    1717    public AbstractIOTask() {
    18         cancelled = false;
     18        canceled = false;
    1919        failed = false;
    2020        lastException = null;
     
    2222
    2323    /**
    24      * Replies true if the task has been cancelled
     24     * Replies true if the task has been canceled
    2525     *
    26      * @return true if the task has been cancelled
     26     * @return true if the task has been canceled
    2727     */
    28     public boolean isCancelled() {
    29         return cancelled;
     28    public boolean isCanceled() {
     29        return canceled;
    3030    }
    3131
    3232    /**
    33      * Set whether this task has been cancelled
     33     * Set whether this task has been canceled
    3434     *
    35      * @param cancelled true, if the task has been cancelled; false otherwise
     35     * @param canceled true, if the task has been canceled; false otherwise
    3636     */
    37     protected void setCancelled(boolean cancelled) {
    38         this.cancelled = cancelled;
     37    protected void setCanceled(boolean canceled) {
     38        this.canceled = canceled;
    3939    }
    4040
     
    7777    /**
    7878     * Replies true if this  task was successful, i.e. if it wasn't
    79      * cancelled and didn't fail
     79     * canceled and didn't fail
    8080     *
    8181     * @return true if this  task was successful
    8282     */
    8383    public boolean isSuccessful() {
    84         return !isCancelled() && !isFailed();
     84        return !isCanceled() && !isFailed();
    8585    }
    8686
  • trunk/src/org/openstreetmap/josm/gui/io/CloseChangesetDialog.java

    r3501 r4310  
    4242    /** the list */
    4343    private JList lstOpenChangesets;
    44     /** true if the user cancelled the dialog */
     44    /** true if the user canceled the dialog */
    4545    private boolean canceled;
    4646    /** the list model */
  • trunk/src/org/openstreetmap/josm/gui/io/CloseChangesetTask.java

    r3083 r4310  
    2323 */
    2424public class CloseChangesetTask extends PleaseWaitRunnable {
    25     private boolean cancelled;
     25    private boolean canceled;
    2626    private Exception lastException;
    2727    private Collection<Changeset> changesets;
     
    4646    @Override
    4747    protected void cancel() {
    48         this.cancelled = true;
     48        this.canceled = true;
    4949        OsmApi.getOsmApi().cancel();
    5050    }
     
    5252    @Override
    5353    protected void finish() {
    54         if (cancelled)
     54        if (canceled)
    5555            return;
    5656        if (lastException != null) {
     
    7070        try {
    7171            for (Changeset cs: changesets) {
    72                 if (cancelled) return;
     72                if (canceled) return;
    7373                if (cs == null || cs.getId() <= 0 || ! cs.isOpen()) {
    7474                    continue;
     
    7979            }
    8080        } catch(Exception e) {
    81             if (cancelled)
     81            if (canceled)
    8282                return;
    8383            lastException = e;
  • trunk/src/org/openstreetmap/josm/gui/io/DownloadOpenChangesetsTask.java

    r3083 r4310  
    3030public class DownloadOpenChangesetsTask extends PleaseWaitRunnable {
    3131
    32     private boolean cancelled;
     32    private boolean canceled;
    3333    private OsmServerChangesetReader reader;
    3434    private List<Changeset> changesets;
     
    4848    @Override
    4949    protected void cancel() {
    50         this.cancelled = true;
     50        this.canceled = true;
    5151        synchronized(this) {
    5252            if (reader != null) {
     
    7171            return;
    7272        }
    73         if (cancelled)return;
     73        if (canceled)return;
    7474        if (lastException != null) {
    7575            ExceptionDialogUtil.explainException(lastException);
     
    133133                refreshUserIdentity();
    134134            }
    135             if (cancelled)return;
     135            if (canceled)return;
    136136            synchronized(this) {
    137137                reader = new OsmServerChangesetReader();
     
    155155            );
    156156        } catch(Exception e) {
    157             if (cancelled)
     157            if (canceled)
    158158                return;
    159159            lastException = e;
     
    161161    }
    162162
    163     public boolean isCancelled() {
    164         return cancelled;
     163    public boolean isCanceled() {
     164        return canceled;
    165165    }
    166166}
  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayerInfo.java

    r3083 r4310  
    143143     * <ul>
    144144     *   <li>{@see UploadOrSaveState#OK} if {@see #getLayer() was successfully uploaded</li>
    145      *   <li>{@see UploadOrSaveState#CANCELLED} if uploading {@see #getLayer() was cancelled</li>
     145     *   <li>{@see UploadOrSaveState#canceled} if uploading {@see #getLayer() was canceled</li>
    146146     *   <li>{@see UploadOrSaveState#FAILED} if uploading {@see #getLayer() has failed</li>
    147147     * </ul>
     
    166166     * <ul>
    167167     *   <li>{@see UploadOrSaveState#OK} if {@see #getLayer() was successfully saved to file</li>
    168      *   <li>{@see UploadOrSaveState#CANCELLED} if saving {@see #getLayer() was cancelled</li>
     168     *   <li>{@see UploadOrSaveState#canceled} if saving {@see #getLayer() was canceled</li>
    169169     *   <li>{@see UploadOrSaveState#FAILED} if saving {@see #getLayer() has failed</li>
    170170     * </ul>
  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayerTask.java

    r4114 r4310  
    5252                return;
    5353            }
    54             if (!isCancelled()) {
     54            if (!isCanceled()) {
    5555                layerInfo.getLayer().onPostSaveToFile();
    5656            }
     
    6363    @Override
    6464    public void cancel() {
    65         setCancelled(true);
     65        setCanceled(true);
    6666    }
    6767}
  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayersDialog.java

    r3501 r4310  
    5050        PROCEED,
    5151        /**
    52          * save/upload of layers was not successful or user cancelled
     52         * save/upload of layers was not successful or user canceled
    5353         * operation
    5454         */
     
    392392        private ProgressMonitor monitor;
    393393        private ExecutorService worker;
    394         private boolean cancelled;
     394        private boolean canceled;
    395395        private Future<?> currentFuture;
    396396        private AbstractIOTask currentTask;
     
    404404        protected void uploadLayers(List<SaveLayerInfo> toUpload) {
    405405            for (final SaveLayerInfo layerInfo: toUpload) {
    406                 if (cancelled) {
    407                     model.setUploadState(layerInfo.getLayer(), UploadOrSaveState.CANCELLED);
     406                if (canceled) {
     407                    model.setUploadState(layerInfo.getLayer(), UploadOrSaveState.CANCELED);
    408408                    continue;
    409409                }
     
    418418                dialog.setVisible(true);
    419419                if (dialog.isCanceled()) {
    420                     model.setUploadState(layerInfo.getLayer(), UploadOrSaveState.CANCELLED);
     420                    model.setUploadState(layerInfo.getLayer(), UploadOrSaveState.CANCELED);
    421421                    continue;
    422422                }
     
    435435                    currentFuture.get();
    436436                } catch(CancellationException e) {
    437                     model.setUploadState(layerInfo.getLayer(), UploadOrSaveState.CANCELLED);
     437                    model.setUploadState(layerInfo.getLayer(), UploadOrSaveState.CANCELED);
    438438                } catch(Exception e) {
    439439                    e.printStackTrace();
     
    441441                    ExceptionDialogUtil.explainException(e);
    442442                }
    443                 if (currentTask.isCancelled()) {
    444                     model.setUploadState(layerInfo.getLayer(), UploadOrSaveState.CANCELLED);
     443                if (currentTask.isCanceled()) {
     444                    model.setUploadState(layerInfo.getLayer(), UploadOrSaveState.CANCELED);
    445445                } else if (currentTask.isFailed()) {
    446446                    currentTask.getLastException().printStackTrace();
     
    457457        protected void saveLayers(List<SaveLayerInfo> toSave) {
    458458            for (final SaveLayerInfo layerInfo: toSave) {
    459                 if (cancelled) {
    460                     model.setSaveState(layerInfo.getLayer(), UploadOrSaveState.CANCELLED);
     459                if (canceled) {
     460                    model.setSaveState(layerInfo.getLayer(), UploadOrSaveState.CANCELED);
    461461                    continue;
    462462                }
     
    469469                    currentFuture.get();
    470470                } catch(CancellationException e) {
    471                     model.setSaveState(layerInfo.getLayer(), UploadOrSaveState.CANCELLED);
     471                    model.setSaveState(layerInfo.getLayer(), UploadOrSaveState.CANCELED);
    472472                } catch(Exception e) {
    473473                    e.printStackTrace();
     
    475475                    ExceptionDialogUtil.explainException(e);
    476476                }
    477                 if (currentTask.isCancelled()) {
    478                     model.setSaveState(layerInfo.getLayer(), UploadOrSaveState.CANCELLED);
     477                if (currentTask.isCanceled()) {
     478                    model.setSaveState(layerInfo.getLayer(), UploadOrSaveState.CANCELED);
    479479                } else if (currentTask.isFailed()) {
    480480                    if (currentTask.getLastException() != null) {
     
    496496            String msg = trn(
    497497                    "<html>An upload and/or save operation of one layer with modifications<br>"
    498                     + "was cancelled or has failed.</html>",
     498                    + "was canceled or has failed.</html>",
    499499                    "<html>Upload and/or save operations of {0} layers with modifications<br>"
    500                     + "were cancelled or have failed.</html>",
     500                    + "were canceled or have failed.</html>",
    501501                    numProblems,
    502502                    numProblems
     
    524524                warnBecauseOfUnsavedData();
    525525                model.setMode(Mode.EDITING_DATA);
    526                 if (cancelled) {
     526                if (canceled) {
    527527                    setUserAction(UserAction.CANCEL);
    528528                    closeDialog();
     
    538538                currentTask.cancel();
    539539            }
    540             cancelled = true;
     540            canceled = true;
    541541        }
    542542    }
  • trunk/src/org/openstreetmap/josm/gui/io/SaveLayersModel.java

    r4114 r4310  
    197197        int ret = 0;
    198198        for (SaveLayerInfo info: layerInfo) {
    199             if (UploadOrSaveState.CANCELLED.equals(info.getSaveState())
    200                     || UploadOrSaveState.CANCELLED.equals(info.getUploadState())) {
     199            if (UploadOrSaveState.CANCELED.equals(info.getSaveState())
     200                    || UploadOrSaveState.CANCELED.equals(info.getUploadState())) {
    201201                ret++;
    202202            }
  • trunk/src/org/openstreetmap/josm/gui/io/UploadDialog.java

    r4191 r4310  
    183183
    184184
    185         // make sure the the configuration panels listen to each other
     185        // make sure the configuration panels listen to each other
    186186        // changes
    187187        //
  • trunk/src/org/openstreetmap/josm/gui/io/UploadLayerTask.java

    r4100 r4310  
    122122                try {
    123123                    ProgressMonitor m = monitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false);
    124                     if (isCancelled()) return;
     124                    if (isCanceled()) return;
    125125                    writer.uploadOsm(strategy, toUpload, changeset, m);
    126126                    processedPrimitives.addAll((Collection) writer.getProcessedPrimitives()); // OsmPrimitive in => OsmPrimitive out
     
    136136            }
    137137        } catch (Exception sxe) {
    138             if (isCancelled()) {
    139                 System.out.println("Ignoring exception caught because upload is cancelled. Exception is: " + sxe.toString());
     138            if (isCanceled()) {
     139                System.out.println("Ignoring exception caught because upload is canceled. Exception is: " + sxe.toString());
    140140                return;
    141141            }
     
    143143        }
    144144
    145         if (isCancelled())
     145        if (isCanceled())
    146146            return;
    147147        layer.cleanupAfterUpload(processedPrimitives);
     
    154154    @Override
    155155    public void cancel() {
    156         setCancelled(true);
     156        setCanceled(true);
    157157        if (writer != null) {
    158158            writer.cancel();
  • trunk/src/org/openstreetmap/josm/gui/io/UploadOrSaveState.java

    r3083 r4310  
    1212    FAILED,
    1313    /**
    14      * uploading or saving a data layer was cancelled
     14     * uploading or saving a data layer was canceled
    1515     */
    16     CANCELLED
     16    CANCELED
    1717}
  • trunk/src/org/openstreetmap/josm/gui/io/UploadPrimitivesTask.java

    r4191 r4310  
    2929import org.openstreetmap.josm.io.OsmApiPrimitiveGoneException;
    3030import org.openstreetmap.josm.io.OsmServerWriter;
    31 import org.openstreetmap.josm.io.OsmTransferCancelledException;
     31import org.openstreetmap.josm.io.OsmTransferCanceledException;
    3232import org.openstreetmap.josm.io.OsmTransferException;
    3333import org.openstreetmap.josm.tools.ImageProvider;
     
    3939 */
    4040public class UploadPrimitivesTask extends  AbstractUploadTask {
    41     private boolean uploadCancelled = false;
     41    private boolean uploadCanceled = false;
    4242    private Exception lastException = null;
    4343    private APIDataSet toUpload;
     
    236236                    //
    237237                    break;
    238                 } catch(OsmTransferCancelledException e) {
     238                } catch(OsmTransferCanceledException e) {
    239239                    e.printStackTrace();
    240                     uploadCancelled = true;
     240                    uploadCanceled = true;
    241241                    break uploadloop;
    242242                } catch(OsmApiPrimitiveGoneException e) {
     
    283283        }
    284284        } catch (Exception e) {
    285             if (uploadCancelled) {
     285            if (uploadCanceled) {
    286286                System.out.println(tr("Ignoring caught exception because upload is canceled. Exception is: {0}", e.toString()));
    287287            } else {
     
    289289            }
    290290        }
    291         if (uploadCancelled && processedPrimitives.isEmpty()) return;
     291        if (uploadCanceled && processedPrimitives.isEmpty()) return;
    292292        cleanupAfterUpload();
    293293    }
    294294
    295295    @Override protected void finish() {
    296         if (uploadCancelled)
     296        if (uploadCanceled)
    297297            return;
    298298
     
    353353
    354354    @Override protected void cancel() {
    355         uploadCancelled = true;
     355        uploadCanceled = true;
    356356        synchronized(this) {
    357357            if (writer != null) {
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/GeoImageLayer.java

    r4241 r4310  
    9090    private static final class Loader extends PleaseWaitRunnable {
    9191
    92         private boolean cancelled = false;
     92        private boolean canceled = false;
    9393        private GeoImageLayer layer;
    9494        private Collection<File> selection;
     
    118118            }
    119119
    120             if (cancelled)
     120            if (canceled)
    121121                return;
    122122            progressMonitor.subTask(tr("Read photos..."));
     
    131131            for (File f : files) {
    132132
    133                 if (cancelled) {
     133                if (canceled) {
    134134                    break;
    135135                }
     
    161161            for (File f : sel) {
    162162
    163                 if(cancelled) {
     163                if(canceled) {
    164164                    break;
    165165                }
     
    241241                }
    242242
    243                 if (! cancelled && layer.data.size() > 0) {
     243                if (! canceled && layer.data.size() > 0) {
    244244                    boolean noGeotagFound = true;
    245245                    for (ImageEntry e : layer.data) {
     
    256256
    257257        @Override protected void cancel() {
    258             cancelled = true;
     258            canceled = true;
    259259        }
    260260    }
  • trunk/src/org/openstreetmap/josm/gui/mappaint/TextElement.java

    r4281 r4310  
    162162     * Replies the label to be rendered for the primitive {@code osm}.
    163163     *
    164      * @param osm the the OSM object
     164     * @param osm the OSM object
    165165     * @return the label, or null, if {@code osm} is null or if no label can be
    166166     * derived for {@code osm}
  • trunk/src/org/openstreetmap/josm/gui/oauth/OAuthAuthorizationWizard.java

    r4191 r4310  
    251251
    252252    /**
    253      * Replies true if the dialog was cancelled
    254      *
    255      * @return true if the dialog was cancelled
     253     * Replies true if the dialog was canceled
     254     *
     255     * @return true if the dialog was canceled
    256256     */
    257257    public boolean isCanceled() {
  • trunk/src/org/openstreetmap/josm/gui/oauth/OsmOAuthAuthorizationClient.java

    r4191 r4310  
    3232import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
    3333import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    34 import org.openstreetmap.josm.io.OsmTransferCancelledException;
     34import org.openstreetmap.josm.io.OsmTransferCanceledException;
    3535import org.openstreetmap.josm.tools.CheckParameterUtil;
    3636
     
    119119     * @throws OsmOAuthAuthorizationException thrown if something goes wrong when retrieving the request token
    120120     */
    121     public OAuthToken getRequestToken(ProgressMonitor monitor) throws OsmOAuthAuthorizationException, OsmTransferCancelledException {
     121    public OAuthToken getRequestToken(ProgressMonitor monitor) throws OsmOAuthAuthorizationException, OsmTransferCanceledException {
    122122        if (monitor == null) {
    123123            monitor = NullProgressMonitor.INSTANCE;
     
    130130        } catch(OAuthCommunicationException e){
    131131            if (canceled)
    132                 throw new OsmTransferCancelledException();
     132                throw new OsmTransferCanceledException();
    133133            throw new OsmOAuthAuthorizationException(e);
    134134        } catch(OAuthException e){
    135135            if (canceled)
    136                 throw new OsmTransferCancelledException();
     136                throw new OsmTransferCanceledException();
    137137            throw new OsmOAuthAuthorizationException(e);
    138138        } finally {
     
    152152     * @see #getRequestToken(ProgressMonitor)
    153153     */
    154     public OAuthToken getAccessToken(ProgressMonitor monitor) throws OsmOAuthAuthorizationException, OsmTransferCancelledException {
     154    public OAuthToken getAccessToken(ProgressMonitor monitor) throws OsmOAuthAuthorizationException, OsmTransferCanceledException {
    155155        if (monitor == null) {
    156156            monitor = NullProgressMonitor.INSTANCE;
     
    163163        } catch(OAuthCommunicationException e){
    164164            if (canceled)
    165                 throw new OsmTransferCancelledException();
     165                throw new OsmTransferCanceledException();
    166166            throw new OsmOAuthAuthorizationException(e);
    167167        } catch(OAuthException e){
    168168            if (canceled)
    169                 throw new OsmTransferCancelledException();
     169                throw new OsmTransferCanceledException();
    170170            throw new OsmOAuthAuthorizationException(e);
    171171        } finally {
     
    465465     * @throws IllegalArgumentException thrown if privileges is null
    466466     * @throws OsmOAuthAuthorizationException thrown if the authorisation fails
    467      * @throws OsmTransferCancelledException thrown if the task is cancelled by the user
    468      */
    469     public void authorise(OAuthToken requestToken, String osmUserName, String osmPassword, OsmPrivileges privileges, ProgressMonitor monitor) throws IllegalArgumentException, OsmOAuthAuthorizationException, OsmTransferCancelledException{
     467     * @throws OsmTransferCanceledException thrown if the task is canceled by the user
     468     */
     469    public void authorise(OAuthToken requestToken, String osmUserName, String osmPassword, OsmPrivileges privileges, ProgressMonitor monitor) throws IllegalArgumentException, OsmOAuthAuthorizationException, OsmTransferCanceledException{
    470470        CheckParameterUtil.ensureParameterNotNull(requestToken, "requestToken");
    471471        CheckParameterUtil.ensureParameterNotNull(osmUserName, "osmUserName");
     
    482482            String sessionId = fetchOsmWebsiteSessionId();
    483483            if (canceled)
    484                 throw new OsmTransferCancelledException();
     484                throw new OsmTransferCanceledException();
    485485            monitor.worked(1);
    486486
     
    488488            authenticateOsmSession(sessionId, osmUserName, osmPassword);
    489489            if (canceled)
    490                 throw new OsmTransferCancelledException();
     490                throw new OsmTransferCanceledException();
    491491            monitor.worked(1);
    492492
     
    494494            sendAuthorisationRequest(sessionId, requestToken, privileges);
    495495            if (canceled)
    496                 throw new OsmTransferCancelledException();
     496                throw new OsmTransferCanceledException();
    497497            monitor.worked(1);
    498498
     
    500500            logoutOsmSession(sessionId);
    501501            if (canceled)
    502                 throw new OsmTransferCancelledException();
     502                throw new OsmTransferCanceledException();
    503503            monitor.worked(1);
    504504        } catch(OsmOAuthAuthorizationException e) {
    505505            if (canceled)
    506                 throw new OsmTransferCancelledException();
     506                throw new OsmTransferCanceledException();
    507507            throw e;
    508508        } finally {
  • trunk/src/org/openstreetmap/josm/gui/oauth/RetrieveAccessTokenTask.java

    r3530 r4310  
    1414import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    1515import org.openstreetmap.josm.gui.help.HelpUtil;
    16 import org.openstreetmap.josm.io.OsmTransferCancelledException;
     16import org.openstreetmap.josm.io.OsmTransferCanceledException;
    1717import org.openstreetmap.josm.io.OsmTransferException;
    1818import org.openstreetmap.josm.tools.CheckParameterUtil;
     
    8484            }
    8585            accessToken = client.getAccessToken(getProgressMonitor().createSubTaskMonitor(0, false));
    86         } catch(OsmTransferCancelledException e) {
     86        } catch(OsmTransferCanceledException e) {
    8787            return;
    8888        } catch (OsmOAuthAuthorizationException e) {
  • trunk/src/org/openstreetmap/josm/gui/oauth/RetrieveRequestTokenTask.java

    r3530 r4310  
    1414import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    1515import org.openstreetmap.josm.gui.help.HelpUtil;
    16 import org.openstreetmap.josm.io.OsmTransferCancelledException;
     16import org.openstreetmap.josm.io.OsmTransferCanceledException;
    1717import org.openstreetmap.josm.io.OsmTransferException;
    1818import org.openstreetmap.josm.tools.CheckParameterUtil;
     
    7878            }
    7979            requestToken = client.getRequestToken(getProgressMonitor().createSubTaskMonitor(0, false));
    80         } catch(OsmTransferCancelledException e) {
     80        } catch(OsmTransferCanceledException e) {
    8181            return;
    8282        } catch (OsmOAuthAuthorizationException e) {
  • trunk/src/org/openstreetmap/josm/gui/preferences/RemoteControlPreference.java

    r3806 r4310  
    8686        wrapper.add(alwaysAskUserConfirm, GBC.eol().fill(GBC.HORIZONTAL));
    8787
    88         final JLabel portLabel = new JLabel("<html>"+tr("JOSM will always listen at port 8111 on localhost." +
     88        final JLabel portLabel = new JLabel("<html>"+tr("JOSM will always listen at port 8111 on localhost. " +
    8989                "This port is not configurable because it is referenced by external applications talking to JOSM.") + "</html>");
    9090        portLabel.setFont(portLabel.getFont().deriveFont(Font.PLAIN));
  • trunk/src/org/openstreetmap/josm/gui/preferences/plugin/PluginUpdatePolicyPanel.java

    r3236 r4310  
    7474        bgVersionBasedUpdatePolicy.add(btn);
    7575
    76         btn = new JRadioButton(tr("Always update withouth asking"));
     76        btn = new JRadioButton(tr("Always update without asking"));
    7777        rbVersionBasedUpatePolicy.put(Policy.ALWAYS, btn);
    7878        bgVersionBasedUpdatePolicy.add(btn);
     
    116116        bgTimeBasedUpdatePolicy.add(btn);
    117117
    118         btn = new JRadioButton(tr("Always update withouth asking"));
     118        btn = new JRadioButton(tr("Always update without asking"));
    119119        btn.addChangeListener(changeListener);
    120120        rbTimeBasedUpatePolicy.put(Policy.ALWAYS, btn);
  • trunk/src/org/openstreetmap/josm/gui/progress/AbstractProgressMonitor.java

    r3083 r4310  
    181181    }
    182182
    183     public boolean isCancelled() {
     183    public boolean isCanceled() {
    184184        return cancelHandler.isCanceled();
    185185    }
  • trunk/src/org/openstreetmap/josm/gui/progress/NullProgressMonitor.java

    r3408 r4310  
    4343    }
    4444
    45     public boolean isCancelled() {
     45    public boolean isCanceled() {
    4646        return false;
    4747    }
  • trunk/src/org/openstreetmap/josm/gui/progress/ProgressMonitor.java

    r3083 r4310  
    115115    ProgressMonitor createSubTaskMonitor(int ticks, boolean internal);
    116116
    117     boolean isCancelled();
     117    boolean isCanceled();
    118118    void cancel();
    119119    void addCancelListener(CancelListener listener);
  • trunk/src/org/openstreetmap/josm/gui/tagging/TagEditorModel.java

    r4191 r4310  
    441441
    442442    /**
    443      * Replies the the tags in this tag editor model as {@see TagCollection}.
    444      *
    445      * @return the the tags in this tag editor model as {@see TagCollection}
     443     * Replies the tags in this tag editor model as {@see TagCollection}.
     444     *
     445     * @return the tags in this tag editor model as {@see TagCollection}
    446446     */
    447447    public TagCollection getTagCollection() {
  • trunk/src/org/openstreetmap/josm/gui/tagging/TagTable.java

    r4191 r4310  
    5151    private TagCellEditor editor = null;
    5252
    53     /** a list of components to which focus can be transferred withouth stopping
     53    /** a list of components to which focus can be transferred without stopping
    5454     * cell editing this table.
    5555     */
  • trunk/src/org/openstreetmap/josm/io/GpxImporter.java

    r3372 r4310  
    5656                    }
    5757                    if (!parsedProperly) {
    58                         JOptionPane.showMessageDialog(null, tr("Error occured while parsing gpx file {0}. Only part of the file will be available", file.getName()));
     58                        JOptionPane.showMessageDialog(null, tr("Error occurred while parsing gpx file {0}. Only a part of the file will be available.", file.getName()));
    5959                    }
    6060                }
  • trunk/src/org/openstreetmap/josm/io/JpgImporter.java

    r3083 r4310  
    4242            addRecursiveFiles(files, visitedDirs, sel, progressMonitor.createSubTaskMonitor(1, true));
    4343
    44             if (progressMonitor.isCancelled())
     44            if (progressMonitor.isCanceled())
    4545                return;
    4646
     
    5656    private void addRecursiveFiles(List<File> files, Set<String> visitedDirs, List<File> sel, ProgressMonitor progressMonitor) throws IOException {
    5757
    58         if (progressMonitor.isCancelled())
     58        if (progressMonitor.isCanceled())
    5959            return;
    6060
  • trunk/src/org/openstreetmap/josm/io/OsmApi.java

    r4191 r4310  
    146146    }
    147147
    148     public void initialize(ProgressMonitor monitor) throws OsmApiInitializationException, OsmTransferCancelledException {
     148    public void initialize(ProgressMonitor monitor) throws OsmApiInitializationException, OsmTransferCanceledException {
    149149        initialize(monitor, false);
    150150    }
     
    156156     * @exception OsmApiInitializationException thrown, if an exception occurs
    157157     */
    158     public void initialize(ProgressMonitor monitor, boolean fastFail) throws OsmApiInitializationException, OsmTransferCancelledException {
     158    public void initialize(ProgressMonitor monitor, boolean fastFail) throws OsmApiInitializationException, OsmTransferCanceledException {
    159159        if (initialized)
    160160            return;
     
    213213            initialized = false;
    214214            throw new OsmApiInitializationException(e);
    215         } catch(OsmTransferCancelledException e){
     215        } catch(OsmTransferCanceledException e){
    216216            throw e;
    217217        } catch(OsmTransferException e) {
     
    477477    }
    478478
    479     private void sleepAndListen(int retry, ProgressMonitor monitor) throws OsmTransferCancelledException {
     479    private void sleepAndListen(int retry, ProgressMonitor monitor) throws OsmTransferCanceledException {
    480480        System.out.print(tr("Waiting 10 seconds ... "));
    481481        for(int i=0; i < 10; i++) {
     
    484484            }
    485485            if (cancel)
    486                 throw new OsmTransferCancelledException();
     486                throw new OsmTransferCanceledException();
    487487            try {
    488488                Thread.sleep(1000);
     
    646646            } catch(IOException e){
    647647                throw new OsmTransferException(e);
    648             } catch(OsmTransferCancelledException e){
     648            } catch(OsmTransferCanceledException e){
    649649                throw e;
    650650            } catch(OsmTransferException e) {
  • trunk/src/org/openstreetmap/josm/io/OsmChangeBuilder.java

    r4100 r4310  
    9191        if (primitives == null) return;
    9292        if (!prologWritten)
    93             throw new IllegalStateException(tr("Prolog of OsmChange document not written yet. Please write frst."));
     93            throw new IllegalStateException(tr("Prolog of OsmChange document not written yet. Please write first."));
    9494        for (IPrimitive p : primitives) {
    9595            write(p);
     
    109109        if (p == null) return;
    110110        if (!prologWritten)
    111             throw new IllegalStateException(tr("Prolog of OsmChange document not written yet. Please write frst."));
     111            throw new IllegalStateException(tr("Prolog of OsmChange document not written yet. Please write first."));
    112112        write(p);
    113113    }
     
    120120    public void finish() throws IllegalStateException {
    121121        if (!prologWritten)
    122             throw new IllegalStateException(tr("Prolog of OsmChange document not written yet. Please write frst."));
     122            throw new IllegalStateException(tr("Prolog of OsmChange document not written yet. Please write first."));
    123123        if (currentMode != null) {
    124124            writer.print("</");
  • trunk/src/org/openstreetmap/josm/io/OsmReader.java

    r4268 r4310  
    158158                    } else {
    159159                        throwException(tr(
    160                                 "Missing manadatory attributes on element ''bounds''. Got minlon=''{0}'',minlat=''{1}'',maxlon=''{3}'',maxlat=''{4}'', origin=''{5}''.",
     160                                "Missing mandatory attributes on element ''bounds''. Got minlon=''{0}'',minlat=''{1}'',maxlon=''{3}'',maxlat=''{4}'', origin=''{5}''.",
    161161                                minlon, minlat, maxlon, maxlat, origin
    162162                        ));
  • trunk/src/org/openstreetmap/josm/io/OsmServerReader.java

    r4191 r4310  
    7171            }
    7272            if (cancel)
    73                 throw new OsmTransferCancelledException();
     73                throw new OsmTransferCanceledException();
    7474            if (Main.pref.getBoolean("osm-server.use-compression", true)) {
    7575                activeConnection.setRequestProperty("Accept-Encoding", "gzip, deflate");
     
    9090
    9191                if (activeConnection.getResponseCode() == HttpURLConnection.HTTP_PROXY_AUTH)
    92                     throw new OsmTransferCancelledException();
     92                    throw new OsmTransferCanceledException();
    9393
    9494                String encoding = activeConnection.getContentEncoding();
  • trunk/src/org/openstreetmap/josm/io/OsmTransferCanceledException.java

    r4304 r4310  
    22package org.openstreetmap.josm.io;
    33
    4 public class OsmTransferCancelledException extends OsmTransferException {
     4public class OsmTransferCanceledException extends OsmTransferException {
    55
    66}
  • trunk/src/org/openstreetmap/josm/io/auth/CredentialsAgentResponse.java

    r4245 r4310  
    2929        return canceled;
    3030    }
    31     public void setCanceled(boolean cancelled) {
    32         this.canceled = cancelled;
     31    public void setCanceled(boolean canceled) {
     32        this.canceled = canceled;
    3333    }
    3434}
  • trunk/src/org/openstreetmap/josm/io/imagery/ImageryReader.java

    r4240 r4310  
    101101            Utils.close(in);
    102102        }
    103         System.err.println("Warning: Could not detect type of imagery source '"+source+"'. Using default (xml).");
     103        Main.warn(tr("Warning: Could not detect type of imagery source '{0}'. Using default (xml).", source));
    104104        return true;
    105105    }
     
    261261            }
    262262            /**
    263              * Did not recognize the element, so the new state is UNKOWN.
     263             * Did not recognize the element, so the new state is UNKNOWN.
    264264             * This includes the case where we are already inside an unknown
    265265             * element, i.e. we do not try to understand the inner content
  • trunk/src/org/openstreetmap/josm/plugins/PluginDownloadTask.java

    r4191 r4310  
    178178
    179179    /**
    180      * Replies true if the task was cancelled by the user
     180     * Replies true if the task was canceled by the user
    181181     *
    182182     * @return
  • trunk/src/org/openstreetmap/josm/plugins/PluginHandler.java

    r4167 r4310  
    354354     * Alerts the user if a plugin required by another plugin is missing
    355355     *
    356      * @param plugin the the plugin
     356     * @param plugin the plugin
    357357     * @param missingRequiredPlugin the missing required plugin
    358358     */
  • trunk/src/org/openstreetmap/josm/plugins/PluginInformation.java

    r4199 r4310  
    7070    /**
    7171     * Creates a plugin information object for the plugin with name {@code name}.
    72      * Information about the plugin is extracted from the maifest file in the the plugin jar
     72     * Information about the plugin is extracted from the maifest file in the plugin jar
    7373     * {@code file}.
    7474     * @param file the plugin jar
  • trunk/src/org/openstreetmap/josm/plugins/ReadLocalPluginInformationTask.java

    r4087 r4310  
    242242
    243243    /**
    244      * Replies true if the task was cancelled by the user
     244     * Replies true if the task was canceled by the user
    245245     *
    246      * @return true if the task was cancelled by the user
     246     * @return true if the task was canceled by the user
    247247     */
    248248    public boolean isCanceled() {
Note: See TracChangeset for help on using the changeset viewer.