Ignore:
Timestamp:
2014-10-21T01:19:59+02:00 (10 years ago)
Author:
donvip
Message:

[josm_canvec_helper] fix sonar issues

Location:
applications/editors/josm/plugins/canvec_helper
Files:
1 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/canvec_helper/.settings/org.eclipse.jdt.core.prefs

    r30736 r30757  
    77org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
    88org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
     9org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
    910org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
     11org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
    1012org.eclipse.jdt.core.compiler.compliance=1.7
     13org.eclipse.jdt.core.compiler.debug.lineNumber=generate
     14org.eclipse.jdt.core.compiler.debug.localVariable=generate
     15org.eclipse.jdt.core.compiler.debug.sourceFile=generate
     16org.eclipse.jdt.core.compiler.doc.comment.support=enabled
    1117org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
    1218org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
    … …  
    3238org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
    3339org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
     40org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
     41org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
     42org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled
     43org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
     44org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=public
    3445org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
    3546org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
    … …  
    3849org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled
    3950org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore
     51org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
     52org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
     53org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public
     54org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=return_tag
     55org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
     56org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters=disabled
     57org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
     58org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=public
    4059org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
    4160org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled

  • applications/editors/josm/plugins/canvec_helper/src/org/openstreetmap/josm/plugins/canvec_helper/CanVecTile.java

    r30738 r30757  
     1// License: GPL
    12package org.openstreetmap.josm.plugins.canvec_helper;
    23
    34import java.util.ArrayList;
    45import java.util.Enumeration;
     6import java.util.List;
    57import java.util.zip.ZipEntry;
    68import java.util.zip.ZipFile;
    79import java.util.regex.Pattern;
    810import java.util.regex.Matcher;
     11
    912import org.openstreetmap.josm.Main;
    1013import org.openstreetmap.josm.data.Bounds;
     14
    1115import java.awt.Point;
     16
    1217import org.openstreetmap.josm.data.coor.LatLon;
    1318import org.openstreetmap.josm.gui.MapView;
    1419import org.openstreetmap.josm.io.IllegalDataException;
    1520import org.openstreetmap.josm.io.CachedFile;
     21
    1622import java.awt.Graphics2D;
    1723import java.awt.Polygon;
    … …  
    1925import java.io.IOException;
    2026import java.io.InputStream;
     27
    2128import org.openstreetmap.josm.io.OsmImporter;
    2229import org.openstreetmap.josm.io.OsmImporter.OsmImporterData;
    2330
    24 public class CanVecTile {
    25     CanvecLayer layer;
    26     public boolean can_download = false;
    27     private ArrayList<String> sub_tile_ids = new ArrayList<>();
    28     private boolean zip_scanned = false;
     31class CanVecTile {
     32    private CanvecLayer layer;
     33    boolean canDownload = false;
     34    private List<String> subTileIds = new ArrayList<>();
     35    private boolean zipScanned = false;
    2936   
    30     private ArrayList<CanVecTile> sub_tiles = new ArrayList<>();
    31     private boolean sub_tiles_made = false;
    32 
    33     private ArrayList<String> index;
     37    private List<CanVecTile> subTiles = new ArrayList<>();
     38    private boolean subTilesMade = false;
     39
     40    private List<String> index;
    3441    private int depth;
    3542   
    36     int corda,cordc;
     43    private int corda;
     44    private int cordc;
    3745    private boolean valid = false;
    38     String cordb,cordd;
     46    private String cordb;
     47    private String cordd;
    3948    private Bounds bounds;
    40     public String tileid;
    41     public CanVecTile(String tileid,CanvecLayer layer) {
     49    String tileid;
     50    CanVecTile(String tileid, CanvecLayer layer) {
    4251        String parta,partb,partc,partd;
    4352        parta = tileid.substring(0,3);
    … …  
    4857        a = Integer.parseInt(parta);
    4958        c = Integer.parseInt(partc);
    50         real_init(a,partb,c,partd,layer,new ArrayList<String>());
    51     }
    52     public CanVecTile(int a,String b,int c,String d,CanvecLayer layer,ArrayList<String> index) {
    53         real_init(a,b,c,d,layer,index);
    54     }
    55     public void real_init(int a,String b,int c,String d,CanvecLayer layer, ArrayList<String> index) {
     59        realInit(a,partb,c,partd,layer,new ArrayList<String>());
     60    }
     61    CanVecTile(int a,String b,int c,String d,CanvecLayer layer, List<String> index) {
     62        realInit(a,b,c,d,layer,index);
     63    }
     64    private void realInit(int a,String b,int c,String d,CanvecLayer layer, List<String> index) {
    5665        this.index = index;
    5766        this.layer = layer;
    … …  
    6069        cordc = c;
    6170        cordd = d;
    62         double zero_point_lat,zero_point_lon;
    63         double lat_span,lon_span;
    64         double lat2,lon2;
     71        double zeroPointLat, zeroPointLon;
     72        double latSpan, lonSpan;
     73        double lat2, lon2;
    6574        if ((a >= 0) && (a <= 119)) { // main block of tiles
    6675            int column = a / 10;
    … …  
    7079                return;
    7180            }
    72             zero_point_lat = 40 + 4 * row;
    73             zero_point_lon = -56 - 8 * column;
     81            zeroPointLat = 40 + 4 * row;
     82            zeroPointLon = -56 - 8 * column;
    7483       
    7584            // size of each grid
    7685            if (row <= 6) {
    7786                // each is 4x8 degrees, broken into a 4x4 grid
    78                 lat_span = 4;
    79                 lon_span = 8;
     87                latSpan = 4;
     88                lonSpan = 8;
    8089                depth = 1;
    8190            } else {
    … …  
    8998        // map A-P to 1-16
    9099        int grid2;
    91         if (b == "") grid2 = 0;
     100        if (b.isEmpty()) grid2 = 0;
    92101        else grid2 = b.charAt(0) - 64;
    93         int rows1[] = { 0, 0,0,0,0, 1,1,1,1, 2,2,2,2, 3,3,3,3 };
    94         int cols1[] = { 0, 3,2,1,0, 0,1,2,3, 3,2,1,0, 0,1,2,3 };
    95         lat2 = zero_point_lat + (lat_span/4)*rows1[grid2];
    96         lon2 = zero_point_lon + (lon_span/4)*cols1[grid2];
     102        int[] rows1 = { 0, 0,0,0,0, 1,1,1,1, 2,2,2,2, 3,3,3,3 };
     103        int[] cols1 = { 0, 3,2,1,0, 0,1,2,3, 3,2,1,0, 0,1,2,3 };
     104        lat2 = zeroPointLat + (latSpan/4)*rows1[grid2];
     105        lon2 = zeroPointLon + (lonSpan/4)*cols1[grid2];
    97106
    98107        if (grid2 != 0) {
    99             lat_span = lat_span / 4;
    100             lon_span = lon_span / 4;
     108            latSpan = latSpan / 4;
     109            lonSpan = lonSpan / 4;
    101110            depth = 2;
    102111        }
    103112
    104         int rows3[] = { 0, 0,0,0,0, 1,1,1,1, 2,2,2,2, 3,3,3,3 };
    105         lat2 = lat2 + (lat_span/4)*rows3[c];
    106         int cols3[] = { 0, 3,2,1,0, 0,1,2,3, 3,2,1,0, 0,1,2,3 };
    107         lon2 = lon2 + (lon_span/4)*cols3[c];
     113        int[] rows3 = { 0, 0,0,0,0, 1,1,1,1, 2,2,2,2, 3,3,3,3 };
     114        lat2 = lat2 + (latSpan/4)*rows3[c];
     115        int[] cols3 = { 0, 3,2,1,0, 0,1,2,3, 3,2,1,0, 0,1,2,3 };
     116        lon2 = lon2 + (lonSpan/4)*cols3[c];
    108117
    109118        if (c != 0) {
    110             lat_span = lat_span / 4;
    111             lon_span = lon_span / 4;
     119            latSpan = latSpan / 4;
     120            lonSpan = lonSpan / 4;
    112121            depth = 3;
    113122        }
    114123       
    115         if (cordd != "") {
     124        if (!cordd.isEmpty()) {
    116125            depth = 4;
    117             System.out.println("cordd: "+cordd);
    118             String foo[] = cordd.split("\\.");
     126            String[] foo = cordd.split("\\.");
    119127            for (int i = 0; i < foo.length; i++) {
    120128                int cell;
    121                 System.out.println(foo[i]);
    122                 if (foo[i] == "osm") break;
    123                 if (foo[i] == "") continue;
     129                if ("osm".equals(foo[i])) break;
     130                if (foo[i].isEmpty()) continue;
    124131                try {
    125132                    cell = Integer.parseInt(foo[i]);
    … …  
    131138                    break;
    132139                case 1:
    133                     lat2 = lat2 + lat_span/2;
     140                    lat2 = lat2 + latSpan/2;
    134141                    break;
    135142                case 2:
    136                     lat2 = lat2 + lat_span/2;
    137                     lon2 = lon2 + lon_span/2;
     143                    lat2 = lat2 + latSpan/2;
     144                    lon2 = lon2 + lonSpan/2;
    138145                    break;
    139146                case 3:
    140                     lon2 = lon2 + lon_span/2;
     147                    lon2 = lon2 + lonSpan/2;
    141148                    break;
    142149                }
    143                 lat_span = lat_span/2;
    144                 lon_span = lon_span/2;
    145             }
    146         }
    147 
    148         bounds = new Bounds(lat2,lon2,lat2+lat_span,lon2+lon_span);
    149         if (cordb == "") this.tileid = String.format("%03d",corda);
     150                latSpan = latSpan/2;
     151                lonSpan = lonSpan/2;
     152            }
     153        }
     154
     155        bounds = new Bounds(lat2,lon2,lat2+latSpan,lon2+lonSpan);
     156        if (cordb.isEmpty()) this.tileid = String.format("%03d",corda);
    150157        else if (cordc == 0) this.tileid = String.format("%03d%s",corda,cordb);
    151         else if (cordd == "") this.tileid = String.format("%03d%s%02d",corda,cordb,cordc);
     158        else if (cordd.isEmpty()) this.tileid = String.format("%03d%s%02d",corda,cordb,cordc);
    152159        else this.tileid = String.format("%03d%s%02d%s",corda,cordb,cordc,cordd);
    153160        valid = true;
    154         //debug(index.toString());
    155         //debug("creating tileid: "+this.tileid);
    156     }
    157     public boolean isValid() { return valid; }
    158     public String getTileId() {
     161    }
     162    boolean isValid() {
     163        return valid;
     164    }
     165    String getTileId() {
    159166        return this.tileid;
    160167    }
    161     private void debug(String line) {
    162         System.out.println(depth + "_" + tileid + ": " + line);
    163     }
    164     public boolean isVisible(Bounds view) {
     168    boolean isVisible(Bounds view) {
    165169        return view.intersects(bounds);
    166170    }
    167     public Point[] getCorners(MapView mv) {
     171    Point[] getCorners(MapView mv) {
    168172        LatLon min = bounds.getMin();
    169173        LatLon max = bounds.getMax();
    … …  
    180184        return String.format("http://ftp2.cits.rncan.gc.ca/OSM/pub/%1$03d/%2$s/%1$03d%2$s%3$02d.zip",corda,cordb,cordc);
    181185    }
    182     private ZipFile open_zip() throws IOException {
    183         File download_path = new File(layer.plugin_self.getPluginDir() + File.separator);
    184         download_path.mkdir();
    185         CachedFile tile_zip = new CachedFile(getDownloadUrl()).setDestDir(download_path.toString());
    186         return new ZipFile(tile_zip.getFile());
    187     }
    188     public void downloadSelf() {
    189         if (zip_scanned) return;
     186    private ZipFile openZip() throws IOException {
     187        File downloadPath = new File(layer.plugin.getPluginDir() + File.separator);
     188        if (!downloadPath.mkdir() && Main.isDebugEnabled()) {
     189            Main.debug("Unable to create directory: "+downloadPath);
     190        }
     191        CachedFile tileZip = new CachedFile(getDownloadUrl()).setDestDir(downloadPath.toString());
     192        return new ZipFile(tileZip.getFile());
     193    }
     194    void downloadSelf() {
     195        if (zipScanned) return;
    190196        ZipFile zipFile;
    191197        try {
    192             zipFile = open_zip();
     198            zipFile = openZip();
    193199        } catch (IOException e) {
    194             e.printStackTrace();
     200            Main.error(e);
    195201            return;
    196202        }
    … …  
    198204        while (entries.hasMoreElements()) {
    199205            ZipEntry entry = entries.nextElement();
    200             if (entry.getName().equals("Metadata.txt")) continue;
    201             sub_tile_ids.add(entry.getName());
    202             zip_scanned = true;
    203             CanVecTile final_tile = new CanVecTile(entry.getName(),layer);
    204             if (final_tile.isValid()) sub_tiles.add(final_tile);
    205         }
    206     }
    207     public void load_raw_osm() {
     206            if ("Metadata.txt".equals(entry.getName())) continue;
     207            subTileIds.add(entry.getName());
     208            zipScanned = true;
     209            CanVecTile finalTile = new CanVecTile(entry.getName(),layer);
     210            if (finalTile.isValid()) {
     211                subTiles.add(finalTile);
     212            }
     213        }
     214    }
     215    void loadRawOsm() {
    208216        ZipFile zipFile;
    209217        try {
    210             zipFile = open_zip();
     218            zipFile = openZip();
    211219            Enumeration<? extends ZipEntry> entries = zipFile.entries();
    212220            while (entries.hasMoreElements()) {
    213221                ZipEntry entry = entries.nextElement();
    214222                if (tileid.equals(entry.getName())) {
    215                     debug("found myself!");
    216223                    InputStream rawtile = zipFile.getInputStream(entry);
    217224                    OsmImporter importer = new OsmImporter();
    218                     debug("loading raw osm");
    219225                    OsmImporterData temp = importer.loadLayer(rawtile, null, entry.getName(), null);
    220226                    Main.worker.submit(temp.getPostLayerTask());
    … …  
    223229                }
    224230            }
    225         } catch (IOException e) {
    226             e.printStackTrace();
     231        } catch (IOException | IllegalDataException e) {
     232            Main.error(e);
    227233            return;
    228         } catch (IllegalDataException e) {
    229             e.printStackTrace();
    230             return;
    231         }
    232     }
    233     private void make_sub_tiles(int layer) {
    234         ArrayList<String> buffer = new ArrayList<>();
     234        }
     235    }
     236    private void makeSubTiles(int layer) {
     237        List<String> buffer = new ArrayList<>();
    235238        Pattern p;
    236         if (sub_tiles_made) return;
     239        if (subTilesMade) return;
    237240        switch (layer) {
    238241        case 1:
    239242            p = Pattern.compile("\\d\\d\\d([A-Z]).*");
    240             String last_cell = "";
     243            String lastCell = "";
    241244            for (int i = 0; i < index.size(); i++) {
    242245                Matcher m = p.matcher(index.get(i));
    … …  
    244247
    245248                String cell = m.group(1);
    246                 if (cell.equals(last_cell)) {
    247                     buffer.add(m.group(0));
    248                 } else if (last_cell == "") {
     249                if (cell.equals(lastCell)) {
     250                    buffer.add(m.group(0));
     251                } else if (lastCell.isEmpty()) {
    249252                    buffer.add(m.group(0));
    250253                } else {
    251                     sub_tiles.add(new CanVecTile(corda,last_cell,0,"",this.layer,buffer));
     254                    subTiles.add(new CanVecTile(corda,lastCell,0,"",this.layer,buffer));
    252255                    buffer = new ArrayList<>();
    253256                    buffer.add(m.group(0));
    254257                }
    255                 last_cell = cell;
    256             }
    257             sub_tiles.add(new CanVecTile(corda,last_cell,0,"",this.layer,buffer));
     258                lastCell = cell;
     259            }
     260            subTiles.add(new CanVecTile(corda,lastCell,0,"",this.layer,buffer));
    258261            break;
    259262        case 2:
    260263            p = Pattern.compile("\\d\\d\\d[A-Z](\\d\\d).*");
    261             int last_cell2 = -1;
     264            int lastCell2 = -1;
    262265            for (int i = 0; i < index.size(); i++) {
    263266                Matcher m = p.matcher(index.get(i));
    … …  
    265268
    266269                int cell = Integer.parseInt(m.group(1));
    267                 if (cell == last_cell2) {
    268                     buffer.add(m.group(0));
    269                 } else if (last_cell2 == -1) {
     270                if (cell == lastCell2) {
     271                    buffer.add(m.group(0));
     272                } else if (lastCell2 == -1) {
    270273                    buffer.add(m.group(0));
    271274                } else {
    272                     sub_tiles.add(new CanVecTile(corda,cordb,last_cell2,"",this.layer,buffer));
     275                    subTiles.add(new CanVecTile(corda,cordb,lastCell2,"",this.layer,buffer));
    273276                    buffer = new ArrayList<>();
    274277                    buffer.add(m.group(0));
    275278                }
    276                 last_cell2 = cell;
    277             }
    278             if (last_cell2 != -1) sub_tiles.add(new CanVecTile(corda,cordb,last_cell2,"",this.layer,buffer));
     279                lastCell2 = cell;
     280            }
     281            if (lastCell2 != -1) subTiles.add(new CanVecTile(corda,cordb,lastCell2,"",this.layer,buffer));
    279282            break;
    280283        }
    281         sub_tiles_made = true;
    282     }
    283     public void paint(Graphics2D g, MapView mv, Bounds bounds, int max_zoom) {
    284         boolean show_sub_tiles = false;
     284        subTilesMade = true;
     285    }
     286    void paint(Graphics2D g, MapView mv, Bounds bounds, int maxZoom) {
     287        boolean showSubTiles = false;
    285288        if (!isVisible(bounds)) return;
    286289        if (depth == 4) {
    … …  
    288291        }
    289292        if ((depth == 3) && (bounds.getArea() < 0.5)) { // 022B01
    290             if (zip_scanned) {
    291                 show_sub_tiles = true;
    292             } else if (can_download) {
     293            if (zipScanned) {
     294                showSubTiles = true;
     295            } else if (canDownload) {
    293296                downloadSelf();
    294                 show_sub_tiles = true;
     297                showSubTiles = true;
    295298            } else {
    296299                layer.downloadable.add(this);
    297300            }
    298301        } else if ((depth == 2) && (bounds.getArea() < 20)) { // its a layer2 tile
    299             make_sub_tiles(2);
    300             show_sub_tiles = true;
     302            makeSubTiles(2);
     303            showSubTiles = true;
    301304        } else if ((depth == 1) && (bounds.getArea() < 40)) { // its a layer1 tile and zoom too small
    302305            // draw layer2 tiles for self
    303             make_sub_tiles(1);
    304             show_sub_tiles = true;
    305         }
    306         if (show_sub_tiles && (depth < max_zoom)) {
    307             for (int i = 0; i < sub_tiles.size(); i++) {
    308                 CanVecTile tile = sub_tiles.get(i);
    309                 tile.paint(g,mv,bounds,max_zoom);
     306            makeSubTiles(1);
     307            showSubTiles = true;
     308        }
     309        if (showSubTiles && (depth < maxZoom)) {
     310            for (int i = 0; i < subTiles.size(); i++) {
     311                CanVecTile tile = subTiles.get(i);
     312                tile.paint(g,mv,bounds,maxZoom);
    310313            }
    311314        } else {
    312             Point corners[] = getCorners(mv);
    313             int xs[] = { corners[0].x, corners[1].x, corners[2].x, corners[3].x };
    314             int ys[] = { corners[0].y, corners[1].y, corners[2].y, corners[3].y };
     315            Point[] corners = getCorners(mv);
     316            int[] xs = { corners[0].x, corners[1].x, corners[2].x, corners[3].x };
     317            int[] ys = { corners[0].y, corners[1].y, corners[2].y, corners[3].y };
    315318            Polygon shape = new Polygon(xs,ys,4);
    316319            g.draw(shape);

  • applications/editors/josm/plugins/canvec_helper/src/org/openstreetmap/josm/plugins/canvec_helper/CanvecHelper.java

    r30738 r30757  
     1// License: GPL
    12package org.openstreetmap.josm.plugins.canvec_helper;
    23
     4import org.openstreetmap.josm.Main;
    35import org.openstreetmap.josm.plugins.Plugin;
    46import org.openstreetmap.josm.plugins.PluginInformation;
    5 import org.openstreetmap.josm.gui.MapFrame;
    6 import org.openstreetmap.josm.Main;
    77
     8/**
     9 * Canvec Helper plugin.
     10 */
    811public class CanvecHelper extends Plugin {
    9    
     12
     13    /**
     14     * Constructs a new {@code CanvecHelper} plugin.
     15     * @param info plugin info
     16     */
    1017    public CanvecHelper(PluginInformation info) {
    1118        super(info);
    1219        Main.main.menu.imagerySubMenu.add(new CanvecHelperAction(this));
    1320    }
    14    
    15     @Override
    16     public void mapFrameInitialized(MapFrame old, MapFrame new1) {
    17         updateLayer();
    18     }
    19    
    20     private synchronized void updateLayer() {
    21     }
    2221}

  • applications/editors/josm/plugins/canvec_helper/src/org/openstreetmap/josm/plugins/canvec_helper/CanvecHelperAction.java

    r30738 r30757  
     1// License: GPL
    12package org.openstreetmap.josm.plugins.canvec_helper;
    23
    … …  
    45import org.openstreetmap.josm.Main;
    56
    6 public class CanvecHelperAction extends JosmAction {
    7     private CanvecHelper parent_temp;
    8     public CanvecHelperAction(CanvecHelper parent) {
     7class CanvecHelperAction extends JosmAction {
     8    private CanvecHelper parentTemp;
     9    CanvecHelperAction(CanvecHelper parent) {
    910        super("CanVec Helper","layericon24",null,null,false);
    10         parent_temp = parent;
     11        parentTemp = parent;
    1112    }
    12         @Override
     13
     14    @Override
    1315    public void actionPerformed(java.awt.event.ActionEvent action) {
    14         CanvecLayer layer;
    15         layer = new CanvecLayer("canvec tile helper",parent_temp);
    16         Main.main.addLayer(layer);
     16        Main.main.addLayer(new CanvecLayer("canvec tile helper",parentTemp));
    1717    }
    1818}

  • applications/editors/josm/plugins/canvec_helper/src/org/openstreetmap/josm/plugins/canvec_helper/CanvecLayer.java

    r30738 r30757  
     1// License: GPL
    12package org.openstreetmap.josm.plugins.canvec_helper;
    23
    … …  
    89import java.awt.Toolkit;
    910import java.awt.event.ActionEvent;
    10 import java.awt.event.MouseEvent;
    11 import java.awt.event.MouseListener;
    1211import java.io.BufferedReader;
    1312import java.io.IOException;
    1413import java.io.InputStream;
    1514import java.io.InputStreamReader;
     15import java.nio.charset.StandardCharsets;
    1616import java.util.ArrayList;
    1717import java.util.List;
    … …  
    3636
    3737// most of the layout was copied from the openstreetbugs plugin to get things started
    38 public class CanvecLayer extends Layer implements MouseListener {
     38class CanvecLayer extends Layer {
    3939    private Icon layerIcon = null;
    40     private int max_zoom = 4;
    41     public CanvecHelper plugin_self;
    42     private ArrayList<CanVecTile> tiles = new ArrayList<>();
    43     public ArrayList<CanVecTile> downloadable = new ArrayList<>();
    44     public ArrayList<CanVecTile> openable = new ArrayList<>();
    45 
    46     public CanvecLayer(String name,CanvecHelper self){
     40    private int maxZoom = 4;
     41    final CanvecHelper plugin;
     42    private List<CanVecTile> tiles = new ArrayList<>();
     43    List<CanVecTile> downloadable = new ArrayList<>();
     44    List<CanVecTile> openable = new ArrayList<>();
     45
     46    CanvecLayer(String name, CanvecHelper self){
    4747        super(name);
    48         plugin_self = self;
     48        plugin = self;
    4949        this.setBackgroundLayer(true);
    50 /*        for (int i = 0; i < 119; i++) {
    51             CanVecTile tile = new CanVecTile(i,"",0,"",plugin_self);
    52             if (tile.isValid()) tiles.add(tile);
    53         }*/
    5450        layerIcon = new ImageIcon(Toolkit.getDefaultToolkit().createImage(getClass().getResource("/images/layericon.png")));
    5551        long start = System.currentTimeMillis();
    5652        try (
    5753            InputStream index = new CachedFile("http://ftp2.cits.rncan.gc.ca/OSM/pub/ZippedOsm.txt").getInputStream();
    58             BufferedReader br = new BufferedReader(new InputStreamReader(index));
     54            BufferedReader br = new BufferedReader(new InputStreamReader(index, StandardCharsets.UTF_8));
    5955        ) {
    6056            Pattern p = Pattern.compile("(\\d\\d\\d)([A-Z]\\d\\d).*");
    6157            String line;
    62             int last_cell = -1;
    63             ArrayList<String> list = new ArrayList<>();
     58            int lastCell = -1;
     59            List<String> list = new ArrayList<>();
    6460            while ((line = br.readLine()) != null) {
    6561                Matcher m = p.matcher(line);
    6662                if (m.find()) {
    6763                    int cell = Integer.parseInt(m.group(1));
    68                     if (cell == last_cell) {
     64                    if (cell == lastCell) {
    6965                        list.add(m.group(0));
    70                     } else if (last_cell != -1) {
    71                         CanVecTile tile = new CanVecTile(last_cell,"",0,"",this,list);
     66                    } else if (lastCell != -1) {
     67                        CanVecTile tile = new CanVecTile(lastCell,"",0,"",this,list);
    7268                        if (tile.isValid()) tiles.add(tile);
    7369                        list = new ArrayList<>();
    7470                        list.add(m.group(0));
    7571                    }
    76                     last_cell = cell;
    77                 } else if (line.contains("Metadata.txt")) {
    78                 } else {
    79                     System.out.print("bad line '" + line + "'\n");
     72                    lastCell = cell;
     73                } else if (!line.contains("Metadata.txt")) {
     74                    Main.warn("bad line '" + line + "'\n");
    8075                }
    8176            }
    82             CanVecTile tile = new CanVecTile(last_cell,"",0,"",this,list);
     77            CanVecTile tile = new CanVecTile(lastCell,"",0,"",this,list);
    8378            if (tile.isValid()) tiles.add(tile);
    8479
    … …  
    10398            new OpenOsmAction(this)};
    10499    }
    105     public class MaxZoomAction extends AbstractAction implements LayerAction {
    106         private CanvecLayer parent;
    107         public MaxZoomAction(CanvecLayer parent) {
     100    private static class MaxZoomAction extends AbstractAction implements LayerAction {
     101        private final CanvecLayer parent;
     102        private MaxZoomAction(CanvecLayer parent) {
    108103            this.parent = parent;
    109104        }
    110                 @Override
    111         public void actionPerformed(ActionEvent e) {}
    112                 @Override
     105        @Override
     106        public void actionPerformed(ActionEvent e) {
     107            // Do nothing
     108        }
     109        @Override
    113110        public boolean supportLayers(List<Layer> layers) {
    114111            return false;
    115112        }
    116                 @Override
     113        @Override
    117114        public Component createMenuComponent() {
    118             JMenu max_zoom = new JMenu("max zoom");
    119             max_zoom.add(new JMenuItem(new SetMaxZoom(parent,1)));
    120             max_zoom.add(new JMenuItem(new SetMaxZoom(parent,2)));
    121             max_zoom.add(new JMenuItem(new SetMaxZoom(parent,3)));
    122             max_zoom.add(new JMenuItem(new SetMaxZoom(parent,4)));
    123             return max_zoom;
    124         }
    125     }
    126     private class AllowDownload extends AbstractAction {
    127         CanVecTile tile;
    128         public AllowDownload(CanVecTile tile) {
     115            JMenu maxZoomMenu = new JMenu("max zoom");
     116            maxZoomMenu.add(new JMenuItem(new SetMaxZoom(parent,1)));
     117            maxZoomMenu.add(new JMenuItem(new SetMaxZoom(parent,2)));
     118            maxZoomMenu.add(new JMenuItem(new SetMaxZoom(parent,3)));
     119            maxZoomMenu.add(new JMenuItem(new SetMaxZoom(parent,4)));
     120            return maxZoomMenu;
     121        }
     122    }
     123    private static class AllowDownload extends AbstractAction {
     124        private final CanVecTile tile;
     125        private AllowDownload(CanVecTile tile) {
    129126            super(tile.tileid);
    130127            this.tile = tile;
    131128        }
    132                 @Override
     129        @Override
    133130        public void actionPerformed(ActionEvent arg0) {
    134             tile.can_download = true;
     131            tile.canDownload = true;
    135132        }
    136133    }
    137134    private class OpenOsmAction extends AbstractAction implements LayerAction {
    138135        private CanvecLayer layer;
    139         public OpenOsmAction(CanvecLayer layer) {
     136        private OpenOsmAction(CanvecLayer layer) {
    140137            this.layer = layer;
    141138        }
    142                 @Override
    143         public void actionPerformed(ActionEvent e) {}
    144                 @Override
     139        @Override
     140        public void actionPerformed(ActionEvent e) {
     141            // Do nothing
     142        }
     143        @Override
    145144        public Component createMenuComponent() {
    146             JMenu OpenOsm = new JMenu("Open tile");
     145            JMenu openOsm = new JMenu("Open tile");
    147146            for (int i = 0; i < layer.openable.size(); i++) {
    148                 OpenOsm.add(new JMenuItem(new DoOpenOsm(layer.openable.get(i))));
    149             }
    150             return OpenOsm;
    151         }
    152                 @Override
     147                openOsm.add(new JMenuItem(new DoOpenOsm(layer.openable.get(i))));
     148            }
     149            return openOsm;
     150        }
     151        @Override
    153152        public boolean supportLayers(List<Layer> layers) {
    154153            return false;
    155154        }
    156155    }
    157     private class DoOpenOsm extends AbstractAction {
    158         CanVecTile tile;
    159         public DoOpenOsm(CanVecTile tile) {
     156    private static class DoOpenOsm extends AbstractAction {
     157        private final CanVecTile tile;
     158        private DoOpenOsm(CanVecTile tile) {
    160159            super(tile.tileid);
    161160            this.tile = tile;
    162161        }
    163                 @Override
    164         public void actionPerformed(ActionEvent e) {
    165             tile.load_raw_osm();
     162        @Override
     163        public void actionPerformed(ActionEvent e) {
     164            tile.loadRawOsm();
    166165        }
    167166    }
    168167    private class DownloadCanvecAction extends AbstractAction implements LayerAction {
    169168        private CanvecLayer parent;
    170         public DownloadCanvecAction(CanvecLayer parent) {
     169        private DownloadCanvecAction(CanvecLayer parent) {
    171170            this.parent = parent;
    172171        }
    173                 @Override
    174         public void actionPerformed(ActionEvent e) {}
    175                 @Override
     172        @Override
     173        public void actionPerformed(ActionEvent e) {
     174            // Do nothing
     175        }
     176        @Override
    176177        public boolean supportLayers(List<Layer> layers) {
    177178            return false;
    178179        }
    179                 @Override
     180        @Override
    180181        public Component createMenuComponent() {
    181182            JMenu downloadCanvec = new JMenu("Download zip's");
    … …  
    186187        }
    187188    }
    188     public void setMaxZoom(int max_zoom) {
    189         this.max_zoom = max_zoom;
    190     }
    191         @Override
     189    void setMaxZoom(int maxZoom) {
     190        this.maxZoom = maxZoom;
     191    }
     192    @Override
    192193    public Object getInfoComponent() {
    193194        return getToolTipText();
    194195    }
    195         @Override
     196    @Override
    196197    public String getToolTipText() {
    197198        return tr("canvec tile helper");
    198199    }
    199         @Override
    200     public void visitBoundingBox(BoundingXYVisitor v) {}
    201         @Override
     200    @Override
     201    public void visitBoundingBox(BoundingXYVisitor v) {
     202        // Do nothing
     203    }
     204    @Override
    202205    public boolean isMergable(Layer other) {
    203206        return false;
    204207    }
    205         @Override
    206     public void mergeFrom(Layer from) {}
    207         @Override
    208     public Icon getIcon() { return layerIcon; }
    209         @Override
     208    @Override
     209    public void mergeFrom(Layer from) {
     210        // Do nothing
     211    }
     212    @Override
     213    public Icon getIcon() {
     214        return layerIcon;
     215    }
     216    @Override
    210217    public void paint(Graphics2D g, MapView mv, Bounds bounds) {
    211         //long start = System.currentTimeMillis();
    212         //System.out.println("painting the area covered by "+bounds.toString());
    213218        downloadable = new ArrayList<>();
    214219        openable = new ArrayList<>();
    … …  
    217222        for (int i = 0; i < tiles.size(); i++) {
    218223            CanVecTile tile = tiles.get(i);
    219             tile.paint(g,mv,bounds,max_zoom);
    220         }
    221         //long end = System.currentTimeMillis();
    222         //System.out.println((end-start)+"ms spent");
    223     }
    224         @Override
    225     public void mouseExited(MouseEvent e) {}
    226         @Override
    227     public void mouseEntered(MouseEvent e) {}
    228         @Override
    229     public void mouseReleased(MouseEvent e) {}
    230         @Override
    231     public void mousePressed(MouseEvent e) {}
    232         @Override
    233     public void mouseClicked(MouseEvent e) {
    234         System.out.println("click!");
     224            tile.paint(g,mv,bounds,maxZoom);
     225        }
    235226    }
    236227}

  • applications/editors/josm/plugins/canvec_helper/src/org/openstreetmap/josm/plugins/canvec_helper/SetMaxZoom.java

    r30738 r30757  
     1// License: GPL
    12package org.openstreetmap.josm.plugins.canvec_helper;
    23
    … …  
    78    private CanvecLayer parent;
    89    private int level;
    9     public SetMaxZoom(CanvecLayer parent,int level) {
     10    SetMaxZoom(CanvecLayer parent,int level) {
    1011        super(""+level);
    1112        this.level = level;
    1213        this.parent = parent;
    1314    }
    14         @Override
     15    @Override
    1516    public void actionPerformed(ActionEvent ev) {
    1617        parent.setMaxZoom(level);
Note: See TracChangeset for help on using the changeset viewer.