Ignore:
Timestamp:
2017-08-24T15:54:00+02:00 (20 months ago)
Author:
Don-vip
Message:

see #15182 - deprecate Main.worker, replace it by gui.MainApplication.worker + code refactoring to make sure only editor packages use it

Location:
trunk/src/org/openstreetmap/josm/gui/io
Files:
3 edited
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/gui/io/AbstractUploadTask.java

    r12620 r12634  
    2626import org.openstreetmap.josm.gui.HelpAwareOptionPane;
    2727import org.openstreetmap.josm.gui.HelpAwareOptionPane.ButtonSpec;
     28import org.openstreetmap.josm.gui.MainApplication;
    2829import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2930import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    9293            throw new IllegalStateException(
    9394                    tr("Failed to update primitive with id {0} because current edit layer does not include such a primitive", id));
    94         Main.worker.execute(new UpdatePrimitivesTask(layer, Collections.singleton(p)));
     95        MainApplication.worker.execute(new UpdatePrimitivesTask(layer, Collections.singleton(p)));
    9596    }
    9697
  • trunk/src/org/openstreetmap/josm/gui/io/ChangesetManagementPanel.java

    r10378 r12634  
    2626import org.openstreetmap.josm.data.osm.Changeset;
    2727import org.openstreetmap.josm.data.osm.ChangesetCache;
     28import org.openstreetmap.josm.gui.MainApplication;
    2829import org.openstreetmap.josm.gui.widgets.JMultilineLabel;
    2930import org.openstreetmap.josm.gui.widgets.JosmComboBox;
     
    299300        @Override
    300301        public void actionPerformed(ActionEvent e) {
    301             DownloadOpenChangesetsTask task = new DownloadOpenChangesetsTask(ChangesetManagementPanel.this);
    302             Main.worker.submit(task);
     302            MainApplication.worker.submit(new DownloadOpenChangesetsTask(ChangesetManagementPanel.this));
    303303        }
    304304    }
     
    319319            Changeset cs = (Changeset) cbOpenChangesets.getSelectedItem();
    320320            if (cs == null) return;
    321             CloseChangesetTask task = new CloseChangesetTask(Collections.singletonList(cs));
    322             Main.worker.submit(task);
     321            MainApplication.worker.submit(new CloseChangesetTask(Collections.singletonList(cs)));
    323322        }
    324323
  • trunk/src/org/openstreetmap/josm/gui/io/CustomConfigurator.java

    r12633 r12634  
    11// License: GPL. For details, see LICENSE file.
    2 package org.openstreetmap.josm.data;
     2package org.openstreetmap.josm.gui.io;
    33
    44import static org.openstreetmap.josm.tools.I18n.tr;
     
    1818import java.util.HashMap;
    1919import java.util.HashSet;
    20 import java.util.Iterator;
    2120import java.util.List;
    2221import java.util.Locale;
    2322import java.util.Map;
    24 import java.util.Map.Entry;
    2523import java.util.Set;
    26 import java.util.TreeMap;
    2724import java.util.regex.Matcher;
    2825import java.util.regex.Pattern;
     
    4542
    4643import org.openstreetmap.josm.Main;
    47 import org.openstreetmap.josm.data.preferences.ListListSetting;
    48 import org.openstreetmap.josm.data.preferences.ListSetting;
    49 import org.openstreetmap.josm.data.preferences.MapListSetting;
     44import org.openstreetmap.josm.data.Preferences;
     45import org.openstreetmap.josm.data.PreferencesUtils;
     46import org.openstreetmap.josm.data.Version;
    5047import org.openstreetmap.josm.data.preferences.Setting;
    51 import org.openstreetmap.josm.data.preferences.StringSetting;
    52 import org.openstreetmap.josm.gui.io.DownloadFileTask;
     48import org.openstreetmap.josm.gui.MainApplication;
    5349import org.openstreetmap.josm.plugins.PluginDownloadTask;
    5450import org.openstreetmap.josm.plugins.PluginInformation;
     
    188184        DownloadFileTask downloadFileTask = new DownloadFileTask(Main.parent, address, fOut, mkdir, unzip);
    189185
    190         Main.worker.submit(downloadFileTask);
     186        MainApplication.worker.submit(downloadFileTask);
    191187        log("Info: downloading file from %s to %s in background ", parentDir, fOut.getAbsolutePath());
    192188        if (unzip) log("and unpacking it"); else log("");
     
    394390                        PluginDownloadTask pluginDownloadTask =
    395391                                new PluginDownloadTask(Main.parent, toInstallPlugins, tr("Installing plugins"));
    396                         Main.worker.submit(pluginDownloadTask);
     392                        MainApplication.worker.submit(pluginDownloadTask);
    397393                    }
    398394                    Collection<String> pls = new ArrayList<>(Main.pref.getCollection("plugins"));
     
    413409            }
    414410        };
    415         Main.worker.submit(task);
    416         Main.worker.submit(r);
     411        MainApplication.worker.submit(task);
     412        MainApplication.worker.submit(r);
    417413    }
    418414
     
    429425        }
    430426        return dir;
    431     }
    432 
    433     public static Preferences clonePreferences(Preferences pref) {
    434         Preferences tmp = new Preferences();
    435         tmp.settingsMap.putAll(pref.settingsMap);
    436         tmp.defaultsMap.putAll(pref.defaultsMap);
    437         tmp.colornames.putAll(pref.colornames);
    438 
    439         return tmp;
    440427    }
    441428
     
    759746        }
    760747    }
    761 
    762     /**
    763      * Helper class to do specific Preferences operation - appending, replacing,
    764      * deletion by key and by value
    765      * Also contains functions that convert preferences object to JavaScript object and back
    766      */
    767     public static final class PreferencesUtils {
    768 
    769         private PreferencesUtils() {
    770             // Hide implicit public constructor for utility class
    771         }
    772 
    773         private static void replacePreferences(Preferences fragment, Preferences mainpref) {
    774             for (Entry<String, Setting<?>> entry: fragment.settingsMap.entrySet()) {
    775                 mainpref.putSetting(entry.getKey(), entry.getValue());
    776             }
    777         }
    778 
    779         private static void appendPreferences(Preferences fragment, Preferences mainpref) {
    780             for (Entry<String, Setting<?>> entry: fragment.settingsMap.entrySet()) {
    781                 String key = entry.getKey();
    782                 if (entry.getValue() instanceof StringSetting) {
    783                     mainpref.putSetting(key, entry.getValue());
    784                 } else if (entry.getValue() instanceof ListSetting) {
    785                     ListSetting lSetting = (ListSetting) entry.getValue();
    786                     Collection<String> newItems = getCollection(mainpref, key, true);
    787                     if (newItems == null) continue;
    788                     for (String item : lSetting.getValue()) {
    789                         // add nonexisting elements to then list
    790                         if (!newItems.contains(item)) {
    791                             newItems.add(item);
    792                         }
    793                     }
    794                     mainpref.putCollection(key, newItems);
    795                 } else if (entry.getValue() instanceof ListListSetting) {
    796                     ListListSetting llSetting = (ListListSetting) entry.getValue();
    797                     Collection<Collection<String>> newLists = getArray(mainpref, key, true);
    798                     if (newLists == null) continue;
    799 
    800                     for (Collection<String> list : llSetting.getValue()) {
    801                         // add nonexisting list (equals comparison for lists is used implicitly)
    802                         if (!newLists.contains(list)) {
    803                             newLists.add(list);
    804                         }
    805                     }
    806                     mainpref.putArray(key, newLists);
    807                 } else if (entry.getValue() instanceof MapListSetting) {
    808                     MapListSetting mlSetting = (MapListSetting) entry.getValue();
    809                     List<Map<String, String>> newMaps = getListOfStructs(mainpref, key, true);
    810                     if (newMaps == null) continue;
    811 
    812                     // get existing properties as list of maps
    813 
    814                     for (Map<String, String> map : mlSetting.getValue()) {
    815                         // add nonexisting map (equals comparison for maps is used implicitly)
    816                         if (!newMaps.contains(map)) {
    817                             newMaps.add(map);
    818                         }
    819                     }
    820                     mainpref.putListOfStructs(entry.getKey(), newMaps);
    821                 }
    822             }
    823         }
    824 
    825         /**
    826          * Delete items from {@code mainpref} collections that match items from {@code fragment} collections.
    827          * @param fragment preferences
    828          * @param mainpref main preferences
    829          */
    830         private static void deletePreferenceValues(Preferences fragment, Preferences mainpref) {
    831 
    832             for (Entry<String, Setting<?>> entry : fragment.settingsMap.entrySet()) {
    833                 String key = entry.getKey();
    834                 if (entry.getValue() instanceof StringSetting) {
    835                     StringSetting sSetting = (StringSetting) entry.getValue();
    836                     // if mentioned value found, delete it
    837                     if (sSetting.equals(mainpref.settingsMap.get(key))) {
    838                         mainpref.put(key, null);
    839                     }
    840                 } else if (entry.getValue() instanceof ListSetting) {
    841                     ListSetting lSetting = (ListSetting) entry.getValue();
    842                     Collection<String> newItems = getCollection(mainpref, key, true);
    843                     if (newItems == null) continue;
    844 
    845                     // remove mentioned items from collection
    846                     for (String item : lSetting.getValue()) {
    847                         log("Deleting preferences: from list %s: %s\n", key, item);
    848                         newItems.remove(item);
    849                     }
    850                     mainpref.putCollection(entry.getKey(), newItems);
    851                 } else if (entry.getValue() instanceof ListListSetting) {
    852                     ListListSetting llSetting = (ListListSetting) entry.getValue();
    853                     Collection<Collection<String>> newLists = getArray(mainpref, key, true);
    854                     if (newLists == null) continue;
    855 
    856                     // if items are found in one of lists, remove that list!
    857                     Iterator<Collection<String>> listIterator = newLists.iterator();
    858                     while (listIterator.hasNext()) {
    859                         Collection<String> list = listIterator.next();
    860                         for (Collection<String> removeList : llSetting.getValue()) {
    861                             if (list.containsAll(removeList)) {
    862                                 // remove current list, because it matches search criteria
    863                                 log("Deleting preferences: list from lists %s: %s\n", key, list);
    864                                 listIterator.remove();
    865                             }
    866                         }
    867                     }
    868 
    869                     mainpref.putArray(key, newLists);
    870                 } else if (entry.getValue() instanceof MapListSetting) {
    871                     MapListSetting mlSetting = (MapListSetting) entry.getValue();
    872                     List<Map<String, String>> newMaps = getListOfStructs(mainpref, key, true);
    873                     if (newMaps == null) continue;
    874 
    875                     Iterator<Map<String, String>> mapIterator = newMaps.iterator();
    876                     while (mapIterator.hasNext()) {
    877                         Map<String, String> map = mapIterator.next();
    878                         for (Map<String, String> removeMap : mlSetting.getValue()) {
    879                             if (map.entrySet().containsAll(removeMap.entrySet())) {
    880                                 // the map contain all mentioned key-value pair, so it should be deleted from "maps"
    881                                 log("Deleting preferences: deleting map from maps %s: %s\n", key, map);
    882                                 mapIterator.remove();
    883                             }
    884                         }
    885                     }
    886                     mainpref.putListOfStructs(entry.getKey(), newMaps);
    887                 }
    888             }
    889         }
    890 
    891     private static void deletePreferenceKeyByPattern(String pattern, Preferences pref) {
    892         Map<String, Setting<?>> allSettings = pref.getAllSettings();
    893         for (Entry<String, Setting<?>> entry : allSettings.entrySet()) {
    894             String key = entry.getKey();
    895             if (key.matches(pattern)) {
    896                 log("Deleting preferences: deleting key from preferences: " + key);
    897                 pref.putSetting(key, null);
    898             }
    899         }
    900     }
    901 
    902     private static void deletePreferenceKey(String key, Preferences pref) {
    903         Map<String, Setting<?>> allSettings = pref.getAllSettings();
    904         if (allSettings.containsKey(key)) {
    905             log("Deleting preferences: deleting key from preferences: " + key);
    906             pref.putSetting(key, null);
    907         }
    908     }
    909 
    910     private static Collection<String> getCollection(Preferences mainpref, String key, boolean warnUnknownDefault) {
    911         ListSetting existing = Utils.cast(mainpref.settingsMap.get(key), ListSetting.class);
    912         ListSetting defaults = Utils.cast(mainpref.defaultsMap.get(key), ListSetting.class);
    913         if (existing == null && defaults == null) {
    914             if (warnUnknownDefault) defaultUnknownWarning(key);
    915             return null;
    916         }
    917         if (existing != null)
    918             return new ArrayList<>(existing.getValue());
    919         else
    920             return defaults.getValue() == null ? null : new ArrayList<>(defaults.getValue());
    921     }
    922 
    923     private static Collection<Collection<String>> getArray(Preferences mainpref, String key, boolean warnUnknownDefault) {
    924         ListListSetting existing = Utils.cast(mainpref.settingsMap.get(key), ListListSetting.class);
    925         ListListSetting defaults = Utils.cast(mainpref.defaultsMap.get(key), ListListSetting.class);
    926 
    927         if (existing == null && defaults == null) {
    928             if (warnUnknownDefault) defaultUnknownWarning(key);
    929             return null;
    930         }
    931         if (existing != null)
    932             return new ArrayList<>(existing.getValue());
    933         else
    934             return defaults.getValue() == null ? null : new ArrayList<>(defaults.getValue());
    935     }
    936 
    937     private static List<Map<String, String>> getListOfStructs(Preferences mainpref, String key, boolean warnUnknownDefault) {
    938         MapListSetting existing = Utils.cast(mainpref.settingsMap.get(key), MapListSetting.class);
    939         MapListSetting defaults = Utils.cast(mainpref.settingsMap.get(key), MapListSetting.class);
    940 
    941         if (existing == null && defaults == null) {
    942             if (warnUnknownDefault) defaultUnknownWarning(key);
    943             return null;
    944         }
    945 
    946         if (existing != null)
    947             return new ArrayList<>(existing.getValue());
    948         else
    949             return defaults.getValue() == null ? null : new ArrayList<>(defaults.getValue());
    950     }
    951 
    952     private static void defaultUnknownWarning(String key) {
    953         log("Warning: Unknown default value of %s , skipped\n", key);
    954         JOptionPane.showMessageDialog(
    955                 Main.parent,
    956                 tr("<html>Settings file asks to append preferences to <b>{0}</b>,<br/> "+
    957                         "but its default value is unknown at this moment.<br/> " +
    958                         "Please activate corresponding function manually and retry importing.", key),
    959                 tr("Warning"),
    960                 JOptionPane.WARNING_MESSAGE);
    961     }
    962 
    963     private static void showPrefs(Preferences tmpPref) {
    964         Logging.info("properties: " + tmpPref.settingsMap);
    965     }
    966 
    967     private static void modifyPreferencesByScript(ScriptEngine engine, Preferences tmpPref, String js) throws ScriptException {
    968         loadPrefsToJS(engine, tmpPref, "API.pref", true);
    969         engine.eval(js);
    970         readPrefsFromJS(engine, tmpPref, "API.pref");
    971     }
    972 
    973     /**
    974      * Convert JavaScript preferences object to preferences data structures
    975      * @param engine - JS engine to put object
    976      * @param tmpPref - preferences to fill from JS
    977      * @param varInJS - JS variable name, where preferences are stored
    978      * @throws ScriptException if the evaluation fails
    979      */
    980     public static void readPrefsFromJS(ScriptEngine engine, Preferences tmpPref, String varInJS) throws ScriptException {
    981         String finish =
    982             "stringMap = new java.util.TreeMap ;"+
    983             "listMap =  new java.util.TreeMap ;"+
    984             "listlistMap = new java.util.TreeMap ;"+
    985             "listmapMap =  new java.util.TreeMap ;"+
    986             "for (key in "+varInJS+") {"+
    987             "  val = "+varInJS+"[key];"+
    988             "  type = typeof val == 'string' ? 'string' : val.type;"+
    989             "  if (type == 'string') {"+
    990             "    stringMap.put(key, val);"+
    991             "  } else if (type == 'list') {"+
    992             "    l = new java.util.ArrayList;"+
    993             "    for (i=0; i<val.length; i++) {"+
    994             "      l.add(java.lang.String.valueOf(val[i]));"+
    995             "    }"+
    996             "    listMap.put(key, l);"+
    997             "  } else if (type == 'listlist') {"+
    998             "    l = new java.util.ArrayList;"+
    999             "    for (i=0; i<val.length; i++) {"+
    1000             "      list=val[i];"+
    1001             "      jlist=new java.util.ArrayList;"+
    1002             "      for (j=0; j<list.length; j++) {"+
    1003             "         jlist.add(java.lang.String.valueOf(list[j]));"+
    1004             "      }"+
    1005             "      l.add(jlist);"+
    1006             "    }"+
    1007             "    listlistMap.put(key, l);"+
    1008             "  } else if (type == 'listmap') {"+
    1009             "    l = new java.util.ArrayList;"+
    1010             "    for (i=0; i<val.length; i++) {"+
    1011             "      map=val[i];"+
    1012             "      jmap=new java.util.TreeMap;"+
    1013             "      for (var key2 in map) {"+
    1014             "         jmap.put(key2,java.lang.String.valueOf(map[key2]));"+
    1015             "      }"+
    1016             "      l.add(jmap);"+
    1017             "    }"+
    1018             "    listmapMap.put(key, l);"+
    1019             "  }  else {" +
    1020             "   org.openstreetmap.josm.data.CustomConfigurator.log('Unknown type:'+val.type+ '- use list, listlist or listmap'); }"+
    1021             "  }";
    1022         engine.eval(finish);
    1023 
    1024         @SuppressWarnings("unchecked")
    1025         Map<String, String> stringMap = (Map<String, String>) engine.get("stringMap");
    1026         @SuppressWarnings("unchecked")
    1027         Map<String, List<String>> listMap = (Map<String, List<String>>) engine.get("listMap");
    1028         @SuppressWarnings("unchecked")
    1029         Map<String, List<Collection<String>>> listlistMap = (Map<String, List<Collection<String>>>) engine.get("listlistMap");
    1030         @SuppressWarnings("unchecked")
    1031         Map<String, List<Map<String, String>>> listmapMap = (Map<String, List<Map<String, String>>>) engine.get("listmapMap");
    1032 
    1033         tmpPref.settingsMap.clear();
    1034 
    1035         Map<String, Setting<?>> tmp = new HashMap<>();
    1036         for (Entry<String, String> e : stringMap.entrySet()) {
    1037             tmp.put(e.getKey(), new StringSetting(e.getValue()));
    1038         }
    1039         for (Entry<String, List<String>> e : listMap.entrySet()) {
    1040             tmp.put(e.getKey(), new ListSetting(e.getValue()));
    1041         }
    1042 
    1043         for (Entry<String, List<Collection<String>>> e : listlistMap.entrySet()) {
    1044             @SuppressWarnings({ "unchecked", "rawtypes" })
    1045             List<List<String>> value = (List) e.getValue();
    1046             tmp.put(e.getKey(), new ListListSetting(value));
    1047         }
    1048         for (Entry<String, List<Map<String, String>>> e : listmapMap.entrySet()) {
    1049             tmp.put(e.getKey(), new MapListSetting(e.getValue()));
    1050         }
    1051         for (Entry<String, Setting<?>> e : tmp.entrySet()) {
    1052             if (e.getValue().equals(tmpPref.defaultsMap.get(e.getKey()))) continue;
    1053             tmpPref.settingsMap.put(e.getKey(), e.getValue());
    1054         }
    1055     }
    1056 
    1057     /**
    1058      * Convert preferences data structures to JavaScript object
    1059      * @param engine - JS engine to put object
    1060      * @param tmpPref - preferences to convert
    1061      * @param whereToPutInJS - variable name to store preferences in JS
    1062      * @param includeDefaults - include known default values to JS objects
    1063      * @throws ScriptException if the evaluation fails
    1064      */
    1065     public static void loadPrefsToJS(ScriptEngine engine, Preferences tmpPref, String whereToPutInJS, boolean includeDefaults)
    1066             throws ScriptException {
    1067         Map<String, String> stringMap = new TreeMap<>();
    1068         Map<String, List<String>> listMap = new TreeMap<>();
    1069         Map<String, List<List<String>>> listlistMap = new TreeMap<>();
    1070         Map<String, List<Map<String, String>>> listmapMap = new TreeMap<>();
    1071 
    1072         if (includeDefaults) {
    1073             for (Map.Entry<String, Setting<?>> e: tmpPref.defaultsMap.entrySet()) {
    1074                 Setting<?> setting = e.getValue();
    1075                 if (setting instanceof StringSetting) {
    1076                     stringMap.put(e.getKey(), ((StringSetting) setting).getValue());
    1077                 } else if (setting instanceof ListSetting) {
    1078                     listMap.put(e.getKey(), ((ListSetting) setting).getValue());
    1079                 } else if (setting instanceof ListListSetting) {
    1080                     listlistMap.put(e.getKey(), ((ListListSetting) setting).getValue());
    1081                 } else if (setting instanceof MapListSetting) {
    1082                     listmapMap.put(e.getKey(), ((MapListSetting) setting).getValue());
    1083                 }
    1084             }
    1085         }
    1086         tmpPref.settingsMap.entrySet().removeIf(e -> e.getValue().getValue() == null);
    1087 
    1088         for (Map.Entry<String, Setting<?>> e: tmpPref.settingsMap.entrySet()) {
    1089             Setting<?> setting = e.getValue();
    1090             if (setting instanceof StringSetting) {
    1091                 stringMap.put(e.getKey(), ((StringSetting) setting).getValue());
    1092             } else if (setting instanceof ListSetting) {
    1093                 listMap.put(e.getKey(), ((ListSetting) setting).getValue());
    1094             } else if (setting instanceof ListListSetting) {
    1095                 listlistMap.put(e.getKey(), ((ListListSetting) setting).getValue());
    1096             } else if (setting instanceof MapListSetting) {
    1097                 listmapMap.put(e.getKey(), ((MapListSetting) setting).getValue());
    1098             }
    1099         }
    1100 
    1101         engine.put("stringMap", stringMap);
    1102         engine.put("listMap", listMap);
    1103         engine.put("listlistMap", listlistMap);
    1104         engine.put("listmapMap", listmapMap);
    1105 
    1106         String init =
    1107             "function getJSList( javaList ) {"+
    1108             " var jsList; var i; "+
    1109             " if (javaList == null) return null;"+
    1110             "jsList = [];"+
    1111             "  for (i = 0; i < javaList.size(); i++) {"+
    1112             "    jsList.push(String(list.get(i)));"+
    1113             "  }"+
    1114             "return jsList;"+
    1115             "}"+
    1116             "function getJSMap( javaMap ) {"+
    1117             " var jsMap; var it; var e; "+
    1118             " if (javaMap == null) return null;"+
    1119             " jsMap = {};"+
    1120             " for (it = javaMap.entrySet().iterator(); it.hasNext();) {"+
    1121             "    e = it.next();"+
    1122             "    jsMap[ String(e.getKey()) ] = String(e.getValue()); "+
    1123             "  }"+
    1124             "  return jsMap;"+
    1125             "}"+
    1126             "for (it = stringMap.entrySet().iterator(); it.hasNext();) {"+
    1127             "  e = it.next();"+
    1128             whereToPutInJS+"[String(e.getKey())] = String(e.getValue());"+
    1129             "}\n"+
    1130             "for (it = listMap.entrySet().iterator(); it.hasNext();) {"+
    1131             "  e = it.next();"+
    1132             "  list = e.getValue();"+
    1133             "  jslist = getJSList(list);"+
    1134             "  jslist.type = 'list';"+
    1135             whereToPutInJS+"[String(e.getKey())] = jslist;"+
    1136             "}\n"+
    1137             "for (it = listlistMap.entrySet().iterator(); it.hasNext(); ) {"+
    1138             "  e = it.next();"+
    1139             "  listlist = e.getValue();"+
    1140             "  jslistlist = [];"+
    1141             "  for (it2 = listlist.iterator(); it2.hasNext(); ) {"+
    1142             "    list = it2.next(); "+
    1143             "    jslistlist.push(getJSList(list));"+
    1144             "    }"+
    1145             "  jslistlist.type = 'listlist';"+
    1146             whereToPutInJS+"[String(e.getKey())] = jslistlist;"+
    1147             "}\n"+
    1148             "for (it = listmapMap.entrySet().iterator(); it.hasNext();) {"+
    1149             "  e = it.next();"+
    1150             "  listmap = e.getValue();"+
    1151             "  jslistmap = [];"+
    1152             "  for (it2 = listmap.iterator(); it2.hasNext();) {"+
    1153             "    map = it2.next();"+
    1154             "    jslistmap.push(getJSMap(map));"+
    1155             "    }"+
    1156             "  jslistmap.type = 'listmap';"+
    1157             whereToPutInJS+"[String(e.getKey())] = jslistmap;"+
    1158             "}\n";
    1159 
    1160             // Execute conversion script
    1161             engine.eval(init);
    1162         }
    1163     }
    1164748}
  • trunk/src/org/openstreetmap/josm/gui/io/RecentlyOpenedFilesMenu.java

    r11366 r12634  
    1919import org.openstreetmap.josm.Main;
    2020import org.openstreetmap.josm.actions.OpenFileAction.OpenFileTask;
     21import org.openstreetmap.josm.gui.MainApplication;
    2122import org.openstreetmap.josm.tools.ImageProvider;
    2223
     
    8586            OpenFileTask task = new OpenFileTask(Collections.singletonList(new File(file)), null);
    8687            task.setRecordHistory(true);
    87             Main.worker.submit(task);
     88            MainApplication.worker.submit(task);
    8889        }
    8990    }
Note: See TracChangeset for help on using the changeset viewer.