Changeset 1450 in josm


Ignore:
Timestamp:
Feb 28, 2009 8:25:46 PM (4 years ago)
Author:
stoecker
Message:

fix #1848 - version in start screen. patch by xeen

Location:
trunk
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/presets/presets.xml

    r1410 r1450  
    23522352        <item name="Vending machine" icon="presets/vending_machine.png" type="node,way,closedway"> 
    23532353            <link href="http://wiki.openstreetmap.org/wiki/Tag:amenity=vending_machine" /> 
    2354             <label text="Edit a Vending_machine" /> 
     2354            <label text="Edit a Vending machine" /> 
    23552355            <key key="amenity" value="vending_machine" /> 
    23562356            <combo key="vending" text="Vending products" values="public_transport_tickets,public_transport_plans,parking_tickets,food,drinks,sweets,cigarettes,photos,animal_food,news_papers,toys,stamps,SIM-cards,telephone_vouchers,vouchers,condoms,tampons,excrement_bags" default="" delete_if_empty="true" /> 

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

    r1420 r1450  
    2525 
    2626import org.openstreetmap.josm.Main; 
     27import org.openstreetmap.josm.io.CacheCustomContent; 
    2728import org.openstreetmap.josm.tools.OpenBrowser; 
    2829import org.openstreetmap.josm.tools.WikiReader; 
    … …  
    3031 
    3132public class GettingStarted extends JPanel { 
    32  
    33     static private String content = ""; 
     33    private String content = ""; 
    3434    static private String styles = "<style type=\"text/css\">\n"+ 
    3535            "body { font-family: sans-serif; font-weight: bold; }\n"+ 
    … …  
    5252    } 
    5353 
    54     public class readMOTD implements Callable<String> { 
     54    /** 
     55     * This class encapsulates the "reading URL" task and can be executed in background and in 
     56     * parallel. Since the MOTD is many separate pages this speeds things up quite a lot. If no 
     57     * localized version is available, it automatically falls back to the international one. 
     58     */ 
     59    private class readMOTD implements Callable<String> { 
    5560        private boolean isLocalized; 
    5661        private boolean isHelp; 
    … …  
    5964        private String urlBase; 
    6065 
    61         readMOTD(boolean isLocalized, String urlBase, String urlLoc, String urlIntl, boolean isHelp) { 
     66        /** 
     67         * Read a MOTD page 
     68         * @param isLocalized If true, tries to get localized version as defined in urlLoc 
     69         * @param urlBase Base URL (i.e. http://www.openstreetmap.de/wiki/) 
     70         * @param urlLoc Part to append to base URL to receive localized version 
     71         * @param urlIntl Part to append to base URL to receive international version 
     72         * @param makeList If true, the URL's contents will be wrapped in a list (<ul><li>) 
     73         */ 
     74        readMOTD(boolean isLocalized, String urlBase, String urlLoc, String urlIntl, boolean makeList) { 
    6275          this.isLocalized = isLocalized; 
    6376          this.urlBase = urlBase; 
    6477          this.urlLoc = urlLoc; 
    6578          this.urlIntl = urlIntl; 
    66           this.isHelp = isHelp; 
    67         } 
    68  
     79          this.isHelp = makeList; 
     80        } 
     81 
     82        /* 
     83         * Does the actual work 
     84         * @see java.util.concurrent.Callable#call() 
     85         */ 
    6986        public String call() { 
    7087            WikiReader wr = new WikiReader(urlBase); 
    7188            String content = ""; 
    7289            try { 
    73                 // If we hit a non-localized link here, we already know there's no translated version available 
     90                // If we hit a non-localized link here, we already know there's no translated 
     91                // version available 
    7492                String message = isLocalized ? wr.read(urlLoc) : ""; 
    7593                // Look for non-localized version 
    … …  
    8199                        content += message; 
    82100                    else 
    83                         content += "<ul><li>"+ message.substring(8).replaceAll("\n *\\* +","</li><li>")+"</li></ul>"; 
     101                        content += "<ul><li>"+ message.substring(8) 
     102                                            .replaceAll("\n *\\* +","</li><li>")+"</li></ul>"; 
    84103            } catch (IOException ioe) { 
    85104                try { 
    … …  
    87106                        content += wr.read(urlIntl); 
    88107                    else 
    89                         content += "<ul><li>"+wr.read(urlIntl).substring(8).replaceAll("\n *\\* +","</li><li>")+"</li></ul>"; 
     108                        content += "<ul><li>"+wr.read(urlIntl).substring(8) 
     109                                            .replaceAll("\n *\\* +","</li><li>")+"</li></ul>"; 
    90110                } catch (IOException ioe2) { 
    91111                } 
    … …  
    96116    } 
    97117 
    98     private void assignContent() { 
    99         if (content.length() > 0 && Main.pref.getBoolean("help.displaymotd", true)) return; 
    100  
    101         String baseurl = Main.pref.get("help.baseurl", "http://josm.openstreetmap.de"); 
    102         WikiReader wr = new WikiReader(baseurl); 
    103         String motdcontent = ""; 
    104         try { 
    105             motdcontent = wr.read(baseurl + "/wiki/MessageOfTheDay?format=txt"); 
    106         } catch (IOException ioe) { 
    107             motdcontent = "<html>" + styles + "<body><h1>" + 
    108                 "JOSM - " + tr("Java OpenStreetMap Editor") + 
    109                 "</h1>\n<h2 align=\"center\">(" + 
    110                 tr ("Message of the day not available") + 
    111                 ")</h2>"; 
    112         } 
    113  
    114         int myVersion = AboutAction.getVersionNumber(); 
    115         String languageCode = Main.getLanguageCodeU(); 
    116  
    117         // Finds wiki links like (underscores inserted for readability): [wiki:LANGCODE:messageoftheday_CONDITON_REVISION LANGCODE] 
    118         // Langcode usually consists of two letters describing the language and may be omitted 
    119         // Condition may be one of the following: >  <  <=  => 
    120         // Revision is the JOSM version 
    121         Pattern versionPattern = Pattern.compile("\\[wiki:(?:[A-Z]+:)?MessageOfTheDay(\\>\\=|\\<\\=|\\<|\\>)([0-9]+)\\s*([A-Z]*)\\]", Pattern.CASE_INSENSITIVE); 
    122         // 1=condition, 2=targetVersion, 3=lang 
    123         Matcher matcher = versionPattern.matcher(motdcontent); 
    124         matcher.reset(); 
    125  
    126         ArrayList<String[]> links = new ArrayList<String[]>(); 
    127         String linksList=""; 
    128         while (matcher.find()) { 
    129             // Discards all but the selected locale and non-localized links 
    130             if(!(matcher.group(3)+":").equals(languageCode) && !matcher.group(3).equals("")) 
    131                 continue; 
    132  
    133             links.add(new String[] {matcher.group(1), matcher.group(2), matcher.group(3)}); 
    134             linksList += matcher.group(1)+matcher.group(2)+matcher.group(3)+": "; 
    135         } 
    136  
    137         // We cannot use Main.worker here because it's single-threaded and 
    138         // setting it to multi-threading will cause problems elsewhere 
    139         ExecutorService slave = Executors.newCachedThreadPool(); 
    140  
    141         ArrayList<Future<String>> linkContent = new ArrayList<Future<String>>(); 
    142         for(int i=0; i < links.size(); i++) { 
    143             String[] obj = links.get(i); 
    144             int targetVersion = Integer.parseInt(obj[1]); 
    145             String condition = obj[0]; 
    146             Boolean isLocalized = !obj[2].equals(""); 
    147  
    148             // Prefer localized over non-localized links, if they're otherwise the same 
    149             if(!isLocalized && linksList.indexOf(condition + obj[1] + languageCode + " ") >= 0) 
    150                 continue; 
    151  
    152             boolean included = false; 
    153  
    154             if(myVersion == 0) 
    155               included = true; 
    156             else if(condition.equals(">=")) 
    157               included=myVersion >= targetVersion; 
    158             else if(condition.equals(">")) 
    159               included = myVersion > targetVersion; 
    160             else if(condition.equals("<")) 
    161               included=myVersion < targetVersion; 
    162             else 
    163               included = myVersion <= targetVersion; 
    164  
    165             if(!included) continue; 
    166  
    167             boolean isHelp = targetVersion == 1; 
    168             String urlStart = baseurl + "/wiki/"; 
    169             String urlEnd = "MessageOfTheDay" + condition + targetVersion + (isHelp ? "" : "?format=txt"); 
    170             String urlLoc = urlStart + languageCode + urlEnd; 
    171             String urlIntl = urlStart + urlEnd; 
    172  
    173             // This adds all links to the worker which will download them concurrently 
    174             linkContent.add(slave.submit(new readMOTD(isLocalized, baseurl, urlLoc, urlIntl, isHelp))); 
    175         } 
    176  
    177         for(int i=0; i < linkContent.size(); i++) { 
     118    /** 
     119     * Grabs current MOTD from cache or webpage and parses it. 
     120     */ 
     121    private class assignContent extends CacheCustomContent { 
     122        public assignContent() { 
     123            super("motd.html", CacheCustomContent.INTERVAL_DAILY); 
     124        } 
     125 
     126        final private int myVersion = AboutAction.getVersionNumber(); 
     127 
     128        /** 
     129         * This function gets executed whenever the cached files need updating 
     130         * @see org.openstreetmap.josm.io.CacheCustomContent#updateData() 
     131         */ 
     132        protected byte[] updateData() { 
     133            String motd = ""; 
     134            String baseurl = Main.pref.get("help.baseurl", "http://josm.openstreetmap.de"); 
     135            WikiReader wr = new WikiReader(baseurl); 
     136            String motdcontent = ""; 
    178137            try { 
    179                 content += linkContent.get(i).get(); 
    180             } catch (Exception e) {} 
    181         } 
    182          
    183         linkContent.clear(); 
    184         try { 
    185             slave.shutdown();  
    186         } catch(SecurityException x) {} 
    187          
    188  
    189         content = "<html>\n"+ 
    190             styles + 
    191             "<h1>JOSM - " + tr("Java OpenStreetMap Editor") + "</h1>\n"+ 
    192             content+"\n"+ 
    193             "</html>"; 
     138                motdcontent = wr.read(baseurl + "/wiki/MessageOfTheDay?format=txt"); 
     139            } catch (IOException ioe) { 
     140                motdcontent = "<html>" + styles + "<body><h1>" + 
     141                    "JOSM - " + tr("Java OpenStreetMap Editor") + 
     142                    "</h1>\n<h2 align=\"center\">(" + 
     143                    tr ("Message of the day not available") + 
     144                    ")</h2>"; 
     145            } 
     146 
     147            String languageCode = Main.getLanguageCodeU(); 
     148 
     149            // Finds wiki links like (underscores inserted for readability): 
     150            // [wiki:LANGCODE:messageoftheday_CONDITON_REVISION LANGCODE] 
     151            // Langcode usually consists of two letters describing the language and may be omitted 
     152            // Condition may be one of the following: >  <  <=  => 
     153            // Revision is the JOSM version 
     154            Pattern versionPattern = Pattern.compile( 
     155                    "\\[wiki:(?:[A-Z]+:)?MessageOfTheDay(\\>\\=|\\<\\=|\\<|\\>)([0-9]+)\\s*([A-Z]*)\\]", 
     156                    Pattern.CASE_INSENSITIVE); 
     157            // 1=condition, 2=targetVersion, 3=lang 
     158            Matcher matcher = versionPattern.matcher(motdcontent); 
     159            matcher.reset(); 
     160 
     161            ArrayList<String[]> links = new ArrayList<String[]>(); 
     162            String linksList=""; 
     163            while (matcher.find()) { 
     164                // Discards all but the selected locale and non-localized links 
     165                if(!(matcher.group(3)+":").equals(languageCode) && !matcher.group(3).equals("")) 
     166                    continue; 
     167 
     168                links.add(new String[] {matcher.group(1), matcher.group(2), matcher.group(3)}); 
     169                linksList += matcher.group(1)+matcher.group(2)+matcher.group(3)+": "; 
     170            } 
     171 
     172            // We cannot use Main.worker here because it's single-threaded and 
     173            // setting it to multi-threading will cause problems elsewhere 
     174            ExecutorService slave = Executors.newCachedThreadPool(); 
     175 
     176            ArrayList<Future<String>> linkContents = new ArrayList<Future<String>>(); 
     177            for(int i=0; i < links.size(); i++) { 
     178                String[] obj = links.get(i); 
     179                int targetVersion = Integer.parseInt(obj[1]); 
     180                String condition = obj[0]; 
     181                Boolean isLocalized = !obj[2].equals(""); 
     182 
     183                // Prefer localized over non-localized links, if they're otherwise the same 
     184                if(!isLocalized && linksList.indexOf(condition + obj[1] + languageCode + " ") >= 0) 
     185                    continue; 
     186 
     187                boolean included = false; 
     188 
     189                if(myVersion == 0) 
     190                  included = true; 
     191                else if(condition.equals(">=")) 
     192                  included=myVersion >= targetVersion; 
     193                else if(condition.equals(">")) 
     194                  included = myVersion > targetVersion; 
     195                else if(condition.equals("<")) 
     196                  included=myVersion < targetVersion; 
     197                else 
     198                  included = myVersion <= targetVersion; 
     199 
     200                if(!included) continue; 
     201 
     202                boolean isHelp = targetVersion == 1; 
     203                String urlStart = baseurl + "/wiki/"; 
     204                String urlEnd = "MessageOfTheDay" + condition + targetVersion 
     205                                    + (isHelp ? "" : "?format=txt"); 
     206                String urlLoc = urlStart + languageCode + urlEnd; 
     207                String urlIntl = urlStart + urlEnd; 
     208 
     209                // This adds all links to the worker which will download them concurrently 
     210                linkContents.add(slave.submit(new readMOTD(isLocalized, baseurl, urlLoc, urlIntl, isHelp))); 
     211            } 
     212            // Gets newest version numbers 
     213            linkContents.add(slave.submit(new readMOTD(false, baseurl, "", 
     214                    baseurl + "/version?format=txt", true))); 
     215 
     216            for(int i=0; i < linkContents.size()-1; i++) { 
     217                try { 
     218                    motd += linkContents.get(i).get(); 
     219                } catch (Exception e) {} 
     220            } 
     221 
     222            motd = "<html>" 
     223                + styles 
     224                + "<h1>JOSM - " 
     225                + tr("Java OpenStreetMap Editor") 
     226                + "</h1>" 
     227                + motd.replace("</html>", "") 
     228                + getVersionNumber(linkContents.get(linkContents.size()-1)) 
     229                + "</html>"; 
     230 
     231            linkContents.clear(); 
     232            try { 
     233                slave.shutdown(); 
     234            } catch(SecurityException x) {} 
     235 
     236            // Save this to prefs in case JOSM is updated so MOTD can be refreshed 
     237            Main.pref.putInteger("cache.motd.html.version", myVersion); 
     238 
     239            return motd.getBytes(); 
     240        } 
     241 
     242        /** 
     243         * Additionally check if JOSM has been updated and refresh MOTD 
     244         */ 
     245        @Override 
     246        protected boolean isCacheValid() { 
     247            // We assume a default of myVersion because it only kicks in in two cases: 
     248            // 1. Not yet written - but so isn't the interval variable, so it gets updated anyway 
     249            // 2. Cannot be written (e.g. while developing). Obviously we don't want to update 
     250            //    everytime because of something we can't read. 
     251            return Main.pref.getInteger("cache.motd.html.version", myVersion) == myVersion; 
     252        } 
     253 
     254        /** 
     255         * Tries to read the version number from a given Future<String> 
     256         * @param Future<String> that contains the version page 
     257         * @return String with HTML Code 
     258         */ 
     259        private String getVersionNumber(Future<String> linkContent) { 
     260            try { 
     261                String str = linkContent.get(); 
     262                Matcher m = Pattern.compile(".*josm-tested\\.jar: *(\\d+).*", Pattern.DOTALL).matcher(str); 
     263                m.matches(); 
     264                int curVersion = Integer.parseInt(m.group(1)); 
     265                m = Pattern.compile(".*josm-latest\\.jar: *(\\d+).*", Pattern.DOTALL).matcher(str); 
     266                m.matches(); 
     267                int latest = Integer.parseInt(m.group(1)); 
     268                return "<div style=\"text-align:right;font-size:small;font-weight:normal;\">" 
     269                + "<b>" 
     270                + (curVersion > myVersion ? tr("Update available") + " &#151; ": "") 
     271                + tr("Version Details:") + "</b> " 
     272                + tr("Yours: {2}; Current: {0}; <font style=\"font-size:x-small\">" 
     273                + "(latest untested: {1} &#150; not recommended)</font>", 
     274                curVersion, latest, myVersion) 
     275                + "</div>"; 
     276            } catch(Exception e) {e.printStackTrace();} 
     277 
     278            return ""; 
     279        } 
    194280    } 
    195281 
     282    /** 
     283     * Initializes getting the MOTD as well as enabling the FileDrop Listener. 
     284     * Displays a message while the MOTD is downloading. 
     285     */ 
    196286    public GettingStarted() { 
    197287        super(new BorderLayout()); 
    … …  
    212302        Thread t = new Thread(new Runnable() { 
    213303            public void run() { 
    214                 assignContent(); 
     304                if (content.length() == 0 && Main.pref.getBoolean("help.displaymotd", true)) 
     305                    content = new assignContent().updateIfRequiredString(); 
     306 
    215307                EventQueue.invokeLater(new Runnable() { 
    216308                    public void run() { 
Note: See TracChangeset for help on using the changeset viewer.