Changeset 4310 in josm


Ignore:
Timestamp:
Aug 11, 2011 12:26:21 AM (23 months 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.