Ignore:
Timestamp:
2016-03-03T08:32:31+01:00 (9 years ago)
Author:
malcolmh
Message:

add RADRFLs

File:
1 edited

Legend:

Unmodified
Added
Removed
  • applications/editors/josm/plugins/seachart/src/render/Rules.java

    r32084 r32090  
    1313import java.awt.Font;
    1414import java.awt.geom.AffineTransform;
     15import java.text.DecimalFormat;
    1516import java.util.ArrayList;
    1617import java.util.EnumMap;
     
    2930public class Rules {
    3031       
     32        static final DecimalFormat df = new DecimalFormat("#.#");
     33
    3134        static final EnumMap<ColCOL, Color> bodyColours = new EnumMap<ColCOL, Color>(ColCOL.class);
    3235        static {
     
    7174        }
    7275
    73         public static void addName(Feature feature, int z, Font font) {
    74                 addName(feature, z, font, Color.black, new Delta(Handle.CC, new AffineTransform()));
    75         }
    76         public static void addName(Feature feature, int z, Font font, Color colour) {
    77                 addName(feature, z, font, colour, new Delta(Handle.CC, new AffineTransform()));
    78         }
    79         public static void addName(Feature feature, int z, Font font, Delta delta) {
    80                 addName(feature, z, font, Color.black, delta);
    81         }
    82         public static void addName(Feature feature, int z, Font font, Color colour, Delta delta) {
     76        public static void addName(int z, Font font) {
     77                addName(z, font, Color.black, new Delta(Handle.CC, new AffineTransform()));
     78        }
     79        public static void addName(int z, Font font, Color colour) {
     80                addName(z, font, colour, new Delta(Handle.CC, new AffineTransform()));
     81        }
     82        public static void addName(int z, Font font, Delta delta) {
     83                addName(z, font, Color.black, delta);
     84        }
     85        public static void addName(int z, Font font, Color colour, Delta delta) {
    8386                if (Renderer.zoom >= z) {
    8487                        String name = getName();
    8588                        if (name != null) {
    86                                 Renderer.labelText(feature, name, font,  colour, delta);
    87                         }
    88                 }
    89         }
    90 
    91         static AttMap getAtts(Feature feature, Obj obj, int idx) {
     89                                Renderer.labelText(name, font,  colour, delta);
     90                        }
     91                }
     92        }
     93
     94        static AttMap getAtts(Obj obj, int idx) {
    9295                HashMap<Integer, AttMap> objs = feature.objs.get(obj);
    9396                if (objs == null)
     
    97100        }
    98101
    99         public static Object getAttVal(Feature feature, Obj obj, int idx, Att att) {
     102        public static Object getAttVal(Obj obj, Att att) {
    100103                AttMap atts;
    101104                HashMap<Integer, AttMap> objs;
    102105                AttVal<?> item;
    103106                if ((objs = feature.objs.get(obj)) != null)
    104                         atts = objs.get(idx);
     107                        atts = objs.get(0);
    105108                else
    106109                        return null;
     
    111114        }
    112115       
    113         public static String getAttStr(Feature feature, Obj obj, int idx, Att att) {
    114                 String str = (String)getAttVal(feature, obj, idx, att);
     116        public static String getAttStr(Obj obj, Att att) {
     117                String str = (String)getAttVal(obj, att);
    115118                if (str != null) {
    116119                        return str;
     
    118121                return "";
    119122        }
    120        
     123
    121124        @SuppressWarnings("unchecked")
    122         public static Enum<?> getAttEnum(Feature feature, Obj obj, int idx, Att att) {
    123                 ArrayList<?> list = (ArrayList<?>)getAttVal(feature, obj, idx, att);
     125        public static Enum<?> getAttEnum(Obj obj, Att att) {
     126                ArrayList<?> list = (ArrayList<?>)getAttVal(obj, att);
    124127                if (list != null) {
    125128                        return ((ArrayList<Enum<?>>)list).get(0);
     
    129132       
    130133        @SuppressWarnings("unchecked")
    131         public static ArrayList<?> getAttList(Feature feature, Obj obj, int idx, Att att) {
    132                 ArrayList<Enum<?>> list = (ArrayList<Enum<?>>)getAttVal(feature, obj, idx, att);
     134        public static ArrayList<?> getAttList(Obj obj, Att att) {
     135                ArrayList<Enum<?>> list = (ArrayList<Enum<?>>)getAttVal(obj, att);
    133136                if (list != null) {
    134137                        return list;
     
    140143       
    141144        @SuppressWarnings("unchecked")
    142         static Scheme getScheme(Feature feature, Obj obj) {
     145        static Scheme getScheme(Obj obj) {
    143146                ArrayList<Color> colours = new ArrayList<Color>();
    144                 for (ColCOL col : (ArrayList<ColCOL>) getAttList(feature, obj, 0, Att.COLOUR)) {
     147                for (ColCOL col : (ArrayList<ColCOL>) getAttList(obj, Att.COLOUR)) {
    145148                        colours.add(bodyColours.get(col));
    146149                }
    147150                ArrayList<Patt> patterns = new ArrayList<Patt>();
    148                 for (ColPAT pat : (ArrayList<ColPAT>) getAttList(feature, obj, 0, Att.COLPAT)) {
     151                for (ColPAT pat : (ArrayList<ColPAT>) getAttList(obj, Att.COLPAT)) {
    149152                        patterns.add(pattMap.get(pat));
    150153                }
    151154                return new Scheme(patterns, colours);
    152155        }
    153        
    154         static boolean testAttribute(Feature feature, Obj obj, int idx, Att att, Object val) {
     156
     157        static boolean hasAttribute(Obj obj, int idx, Att att) {
    155158                AttMap atts;
    156                 if ((atts = getAtts(feature, obj, idx)) != null) {
     159                if ((atts = getAtts(obj, idx)) != null) {
     160                        AttVal<?> item = atts.get(att);
     161                        return item != null;
     162                }
     163                return false;
     164        }
     165       
     166        static boolean testAttribute(Obj obj, Att att, Object val) {
     167                AttMap atts;
     168                if ((atts = getAtts(obj, 0)) != null) {
    157169                        AttVal<?> item = atts.get(att);
    158170                        if (item != null) {
     
    161173                                case A:
    162174                                        return ((String)item.val).equals(val);
     175                                case E:
    163176                                case L:
    164177                                        return ((ArrayList<?>)item.val).contains(val);
    165                                 case E:
    166178                                case F:
    167179                                case I:
    168                                         return item.val.equals(val);
     180                                        return item.val == val;
    169181                                }
    170182                        }
     
    173185        }
    174186       
    175         static Feature feature;
     187        public static Feature feature;
    176188        static ArrayList<Feature> objects;
    177189       
     
    248260                        if (testObject(Obj.CGUSTA)) for (Feature f : objects) if (testFeature(f)) stations();
    249261                        if (testObject(Obj.RDOSTA)) for (Feature f : objects) if (testFeature(f)) stations();
     262                        if (testObject(Obj.RADRFL)) for (Feature f : objects) if (testFeature(f)) stations();
    250263                        if (testObject(Obj.RADSTA)) for (Feature f : objects) if (testFeature(f)) stations();
    251264                        if (testObject(Obj.RTPBCN)) for (Feature f : objects) if (testFeature(f)) stations();
     
    275288                switch (feature.type) {
    276289                case BUAARE:
    277                         Renderer.lineVector(feature, new LineStyle(new Color(0x20000000, true)));
     290                        Renderer.lineVector(new LineStyle(new Color(0x20000000, true)));
    278291                        break;
    279292                case COALNE:
    280293                        if (Renderer.zoom >= 12)
    281                                 Renderer.lineVector(feature, new LineStyle(Color.black, 10));
     294                                Renderer.lineVector(new LineStyle(Color.black, 10));
    282295                        break;
    283296                case DEPARE:
    284297                        Double depmax = 0.0;
    285                         if (((depmax = (Double) getAttVal(feature, Obj.DEPARE, 0, Att.DRVAL2)) != null) && (depmax <= 0.0)) {
    286                                 Renderer.lineVector(feature, new LineStyle(Symbols.Gdries));
     298                        if (((depmax = (Double) getAttVal(Obj.DEPARE, Att.DRVAL2)) != null) && (depmax <= 0.0)) {
     299                                Renderer.lineVector(new LineStyle(Symbols.Gdries));
    287300                        }
    288301                        break;
    289302                case LAKARE:
    290303                        if ((Renderer.zoom >= 12) || (feature.geom.area > 10.0))
    291                                 Renderer.lineVector(feature, new LineStyle(Symbols.Bwater));
     304                                Renderer.lineVector(new LineStyle(Symbols.Bwater));
    292305                        break;
    293306                case DRGARE:
    294307                        if (Renderer.zoom < 16)
    295                                 Renderer.lineVector(feature, new LineStyle(Color.black, 8, new float[] { 25, 25 }, new Color(0x40ffffff, true)));
     308                                Renderer.lineVector(new LineStyle(Color.black, 8, new float[] { 25, 25 }, new Color(0x40ffffff, true)));
    296309                        else
    297                                 Renderer.lineVector(feature, new LineStyle(Color.black, 8, new float[] { 25, 25 }));
    298                         addName(feature, 12, new Font("Arial", Font.PLAIN, 100), new Delta(Handle.CC, new AffineTransform()));
     310                                Renderer.lineVector(new LineStyle(Color.black, 8, new float[] { 25, 25 }));
     311                        addName(12, new Font("Arial", Font.PLAIN, 100), new Delta(Handle.CC, new AffineTransform()));
    299312                        break;
    300313                case FAIRWY:
    301314                        if (feature.geom.area > 2.0) {
    302315                                if (Renderer.zoom < 16)
    303                                         Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 8, new float[] { 50, 50 }, new Color(0x40ffffff, true)));
     316                                        Renderer.lineVector(new LineStyle(Symbols.Mline, 8, new float[] { 50, 50 }, new Color(0x40ffffff, true)));
    304317                                else
    305                                         Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 8, new float[] { 50, 50 }));
     318                                        Renderer.lineVector(new LineStyle(Symbols.Mline, 8, new float[] { 50, 50 }));
    306319                        } else {
    307320                                if (Renderer.zoom >= 14)
    308                                         Renderer.lineVector(feature, new LineStyle(new Color(0x40ffffff, true)));
     321                                        Renderer.lineVector(new LineStyle(new Color(0x40ffffff, true)));
    309322                        }
    310323                        break;
     
    313326                case HRBBSN:
    314327                        if (Renderer.zoom >= 12) {
    315                                 Renderer.lineVector(feature, new LineStyle(Color.black, 10, Symbols.Bwater));
     328                                Renderer.lineVector(new LineStyle(Color.black, 10, Symbols.Bwater));
    316329                        } else {
    317                                 Renderer.lineVector(feature, new LineStyle(Symbols.Bwater));
     330                                Renderer.lineVector(new LineStyle(Symbols.Bwater));
    318331                        }
    319332                        break;
     
    321334                        if (feature.objs.get(Obj.HRBBSN) != null) {
    322335                                if (Renderer.zoom >= 12) {
    323                                         Renderer.lineVector(feature, new LineStyle(Color.black, 10, Symbols.Bwater));
     336                                        Renderer.lineVector(new LineStyle(Color.black, 10, Symbols.Bwater));
    324337                                } else {
    325                                         Renderer.lineVector(feature, new LineStyle(Symbols.Bwater));
     338                                        Renderer.lineVector(new LineStyle(Symbols.Bwater));
    326339                                }
    327340                        }
    328341                        break;
    329342                case LNDARE:
    330                         Renderer.lineVector(feature, new LineStyle(Symbols.Yland));
     343                        Renderer.lineVector(new LineStyle(Symbols.Yland));
    331344                        break;
    332345                case MARCUL:
    333346                        if (Renderer.zoom >= 12) {
    334347                                if (Renderer.zoom >= 14) {
    335                                         Renderer.symbol(feature, Areas.MarineFarm);
     348                                        Renderer.symbol(Areas.MarineFarm);
    336349                                }
    337350                                if ((feature.geom.area > 0.2) || ((feature.geom.area > 0.05) && (Renderer.zoom >= 14)) || ((feature.geom.area > 0.005) && (Renderer.zoom >= 16))) {
    338                                         Renderer.lineVector(feature, new LineStyle(Color.black, 4, new float[] { 10, 10 }));
     351                                        Renderer.lineVector(new LineStyle(Color.black, 4, new float[] { 10, 10 }));
    339352                                }
    340353                        }
    341354                        break;
    342355                case OSPARE:
    343                         if (testAttribute(feature, feature.type, 0, Att.CATPRA, CatPRA.PRA_WFRM)) {
    344                                 Renderer.symbol(feature, Areas.WindFarm);
    345                                 Renderer.lineVector(feature, new LineStyle(Color.black, 20, new float[] { 40, 40 }));
    346                                 addName(feature, 15, new Font("Arial", Font.BOLD, 80), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, 10)));
     356                        if (testAttribute(feature.type, Att.CATPRA, CatPRA.PRA_WFRM)) {
     357                                Renderer.symbol(Areas.WindFarm);
     358                                Renderer.lineVector(new LineStyle(Color.black, 20, new float[] { 40, 40 }));
     359                                addName(15, new Font("Arial", Font.BOLD, 80), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, 10)));
    347360                        }
    348361                        break;
     
    350363                case MIPARE:
    351364                        if (Renderer.zoom >= 12) {
    352                                 Renderer.lineSymbols(feature, Areas.Restricted, 1.0, null, null, 0, Symbols.Mline);
    353                                 if (testAttribute(feature, feature.type, 0, Att.CATREA, CatREA.REA_NWAK)) {
    354                                         Renderer.symbol(feature, Areas.NoWake);
     365                                Renderer.lineSymbols(Areas.Restricted, 1.0, null, null, 0, Symbols.Mline);
     366                                if (testAttribute(feature.type, Att.CATREA, CatREA.REA_NWAK)) {
     367                                        Renderer.symbol(Areas.NoWake);
    355368                                }
    356369                        }
     
    358371                case PRCARE:
    359372                        if (Renderer.zoom >= 12) {
    360                                 Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 10, new float[] { 40, 40 }));
     373                                Renderer.lineVector(new LineStyle(Symbols.Mline, 10, new float[] { 40, 40 }));
    361374                        }
    362375                        break;
    363376                case SEAARE:
    364                         switch ((CatSEA) getAttEnum(feature, feature.type, 0, Att.CATSEA)) {
     377                        switch ((CatSEA) getAttEnum(feature.type, Att.CATSEA)) {
    365378                        case SEA_RECH:
    366379                                if ((Renderer.zoom >= 10) && (name != null))
    367380                                        if (feature.geom.prim == Pflag.LINE) {
    368                                                 Renderer.lineText(feature, name, new Font("Arial", Font.PLAIN, 150), Color.black, 0.5, -40);
     381                                                Renderer.lineText(name, new Font("Arial", Font.PLAIN, 150), Color.black, 0.5, -40);
    369382                                        } else {
    370                                                 Renderer.labelText(feature, name, new Font("Arial", Font.PLAIN, 150), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
     383                                                Renderer.labelText(name, new Font("Arial", Font.PLAIN, 150), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
    371384                                        }
    372385                                break;
     
    374387                                if ((Renderer.zoom >= 12) && (name != null))
    375388                                        if (feature.geom.prim == Pflag.LINE) {
    376                                                 Renderer.lineText(feature, name, new Font("Arial", Font.PLAIN, 150), Color.black, 0.5, -40);
     389                                                Renderer.lineText(name, new Font("Arial", Font.PLAIN, 150), Color.black, 0.5, -40);
    377390                                        } else {
    378                                                 Renderer.labelText(feature, name, new Font("Arial", Font.PLAIN, 150), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
     391                                                Renderer.labelText(name, new Font("Arial", Font.PLAIN, 150), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
    379392                                        }
    380393                                break;
     
    382395                                if (Renderer.zoom >= 14) {
    383396                                        if (feature.geom.prim == Pflag.AREA) {
    384                                                 Renderer.lineVector(feature, new LineStyle(new Color(0xc480ff), 4, new float[] { 25, 25 }));
     397                                                Renderer.lineVector(new LineStyle(new Color(0xc480ff), 4, new float[] { 25, 25 }));
    385398                                                if (name != null) {
    386                                                         Renderer.labelText(feature, name, new Font("Arial", Font.ITALIC, 75), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
    387                                                         Renderer.labelText(feature, "(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, new Delta(Handle.BC));
     399                                                        Renderer.labelText(name, new Font("Arial", Font.ITALIC, 75), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
     400                                                        Renderer.labelText("(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, new Delta(Handle.BC));
    388401                                                }
    389402                                        } else if (feature.geom.prim == Pflag.LINE) {
    390403                                                if (name != null) {
    391                                                         Renderer.lineText(feature, name, new Font("Arial", Font.ITALIC, 75), Color.black, 0.5, -40);
    392                                                         Renderer.lineText(feature, "(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, 0);
     404                                                        Renderer.lineText(name, new Font("Arial", Font.ITALIC, 75), Color.black, 0.5, -40);
     405                                                        Renderer.lineText("(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, 0);
    393406                                                }
    394407                                        } else {
    395408                                                if (name != null) {
    396                                                         Renderer.labelText(feature, name, new Font("Arial", Font.ITALIC, 75), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
    397                                                         Renderer.labelText(feature, "(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, new Delta(Handle.BC));
     409                                                        Renderer.labelText(name, new Font("Arial", Font.ITALIC, 75), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
     410                                                        Renderer.labelText("(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, new Delta(Handle.BC));
    398411                                                }
    399412                                        }
     
    402415                        case SEA_GAT:
    403416                        case SEA_NRRW:
    404                                 addName(feature, 12, new Font("Arial", Font.PLAIN, 100));
     417                                addName(12, new Font("Arial", Font.PLAIN, 100));
    405418                                break;
    406419                        default:
     
    409422                        break;
    410423                case SNDWAV:
    411                         if (Renderer.zoom >= 12) Renderer.fillPattern(feature, Areas.Sandwaves);
     424                        if (Renderer.zoom >= 12) Renderer.fillPattern(Areas.Sandwaves);
    412425                        break;
    413426                case SPLARE:
    414427                        if (Renderer.zoom >= 12) {
    415                                 Renderer.symbol(feature, Areas.Plane, new Scheme(Symbols.Msymb));
    416                                 Renderer.lineSymbols(feature, Areas.Restricted, 0.5, Areas.LinePlane, null, 10, Symbols.Mline);
    417                         }
    418                         addName(feature, 15, new Font("Arial", Font.BOLD, 80), new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -90)));
     428                                Renderer.symbol(Areas.Plane, new Scheme(Symbols.Msymb));
     429                                Renderer.lineSymbols(Areas.Restricted, 0.5, Areas.LinePlane, null, 10, Symbols.Mline);
     430                        }
     431                        addName(15, new Font("Arial", Font.BOLD, 80), new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -90)));
    419432                        break;
    420433                default:
     
    426439        private static void beacons() {
    427440                if ((Renderer.zoom >= 14) || ((Renderer.zoom >= 12) && ((feature.type == Obj.BCNLAT) || (feature.type == Obj.BCNCAR)))) {
    428                         BcnSHP shape = (BcnSHP)getAttEnum(feature, feature.type, 0, Att.BCNSHP);
     441                        BcnSHP shape = (BcnSHP)getAttEnum(feature.type, Att.BCNSHP);
    429442                        if (shape == BcnSHP.BCN_UNKN)
    430443                                shape = BcnSHP.BCN_PILE;
    431444                        if ((shape == BcnSHP.BCN_WTHY) && (feature.type == Obj.BCNLAT)) {
    432                                 switch ((CatLAM) getAttEnum(feature, feature.type, 0, Att.CATLAM)) {
     445                                switch ((CatLAM) getAttEnum(feature.type, Att.CATLAM)) {
    433446                                case LAM_PORT:
    434                                         Renderer.symbol(feature, Beacons.WithyPort);
     447                                        Renderer.symbol(Beacons.WithyPort);
    435448                                        break;
    436449                                case LAM_STBD:
    437                                         Renderer.symbol(feature, Beacons.WithyStarboard);
     450                                        Renderer.symbol(Beacons.WithyStarboard);
    438451                                        break;
    439452                                default:
    440                                         Renderer.symbol(feature, Beacons.Stake, getScheme(feature, feature.type));
     453                                        Renderer.symbol(Beacons.Stake, getScheme(feature.type));
    441454                                }
    442455                        } else if ((shape == BcnSHP.BCN_PRCH) && (feature.type == Obj.BCNLAT) && !(feature.objs.containsKey(Obj.TOPMAR))) {
    443                                 switch ((CatLAM) getAttEnum(feature, feature.type, 0, Att.CATLAM)) {
     456                                switch ((CatLAM) getAttEnum(feature.type, Att.CATLAM)) {
    444457                                case LAM_PORT:
    445                                         Renderer.symbol(feature, Beacons.PerchPort);
     458                                        Renderer.symbol(Beacons.PerchPort);
    446459                                        break;
    447460                                case LAM_STBD:
    448                                         Renderer.symbol(feature, Beacons.PerchStarboard);
     461                                        Renderer.symbol(Beacons.PerchStarboard);
    449462                                        break;
    450463                                default:
    451                                         Renderer.symbol(feature, Beacons.Stake, getScheme(feature, feature.type));
     464                                        Renderer.symbol(Beacons.Stake, getScheme(feature.type));
    452465                                }
    453466                        } else {
    454                                 Renderer.symbol(feature, Beacons.Shapes.get(shape), getScheme(feature, feature.type));
     467                                Renderer.symbol(Beacons.Shapes.get(shape), getScheme(feature.type));
    455468                                if (feature.objs.containsKey(Obj.TOPMAR)) {
    456469                                        AttMap topmap = feature.objs.get(Obj.TOPMAR).get(0);
    457470                                        if (topmap.containsKey(Att.TOPSHP)) {
    458                                                 Renderer.symbol(feature, Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(feature, Obj.TOPMAR), Topmarks.BeaconDelta);
     471                                                Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.TOPMAR), Topmarks.BeaconDelta);
    459472                                        }
    460473                                } else if (feature.objs.containsKey(Obj.DAYMAR)) {
    461474                                        AttMap topmap = feature.objs.get(Obj.DAYMAR).get(0);
    462475                                        if (topmap.containsKey(Att.TOPSHP)) {
    463                                                 Renderer.symbol(feature, Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(feature, Obj.DAYMAR), Topmarks.BeaconDelta);
    464                                         }
    465                                 }
    466                         }
    467                         addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
    468                         Signals.addSignals(feature);
     476                                                Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.DAYMAR), Topmarks.BeaconDelta);
     477                                        }
     478                                }
     479                        }
     480                        addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
     481                        Signals.addSignals();
    469482                }
    470483        }
     
    473486        private static void buoys() {
    474487                if ((Renderer.zoom >= 14) || ((Renderer.zoom >= 12) && ((feature.type == Obj.BOYLAT) || (feature.type == Obj.BOYCAR)))) {
    475                         BoySHP shape = (BoySHP) getAttEnum(feature, feature.type, 0, Att.BOYSHP);
     488                        BoySHP shape = (BoySHP) getAttEnum(feature.type, Att.BOYSHP);
    476489                        if (shape == BoySHP.BOY_UNKN) shape = BoySHP.BOY_PILR;
    477                         Renderer.symbol(feature, Buoys.Shapes.get(shape), getScheme(feature, feature.type));
     490                        Renderer.symbol(Buoys.Shapes.get(shape), getScheme(feature.type));
    478491                        if (feature.objs.containsKey(Obj.TOPMAR)) {
    479492                                AttMap topmap = feature.objs.get(Obj.TOPMAR).get(0);
    480493                                if (topmap.containsKey(Att.TOPSHP)) {
    481                                         Renderer.symbol(feature, Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(feature, Obj.TOPMAR), Topmarks.BuoyDeltas.get(shape));
     494                                        Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.TOPMAR), Topmarks.BuoyDeltas.get(shape));
    482495                                }
    483496                        } else if (feature.objs.containsKey(Obj.DAYMAR)) {
    484497                                AttMap topmap = feature.objs.get(Obj.DAYMAR).get(0);
    485498                                if (topmap.containsKey(Att.TOPSHP)) {
    486                                         Renderer.symbol(feature, Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(feature, Obj.DAYMAR), Topmarks.BuoyDeltas.get(shape));
    487                                 }
    488                         }
    489                         addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
    490                         Signals.addSignals(feature);
     499                                        Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.DAYMAR), Topmarks.BuoyDeltas.get(shape));
     500                                }
     501                        }
     502                        addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
     503                        Signals.addSignals();
    491504                }
    492505        }
     
    520533                                }
    521534                                if (hstr.isEmpty() && !vstr.isEmpty()) {
    522                                         Renderer.labelText(feature, vstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.VCLR, Color.black, Color.white, new Delta(Handle.CC));
     535                                        Renderer.labelText(vstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.VCLR, Color.black, Color.white, new Delta(Handle.CC));
    523536                                } else if (!hstr.isEmpty() && !vstr.isEmpty()) {
    524                                         Renderer.labelText(feature, vstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.VCLR, Color.black, Color.white, new Delta(Handle.BC));
    525                                         Renderer.labelText(feature, hstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.HCLR, Color.black, Color.white, new Delta(Handle.TC));
     537                                        Renderer.labelText(vstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.VCLR, Color.black, Color.white, new Delta(Handle.BC));
     538                                        Renderer.labelText(hstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.HCLR, Color.black, Color.white, new Delta(Handle.TC));
    526539                                } else if (!hstr.isEmpty() && vstr.isEmpty()) {
    527                                         Renderer.labelText(feature, hstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.HCLR, Color.black, Color.white, new Delta(Handle.CC));
     540                                        Renderer.labelText(hstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.HCLR, Color.black, Color.white, new Delta(Handle.CC));
    528541                                }
    529542                        }
     
    534547                if ((Renderer.zoom >= 16) && (feature.geom.length < 2)) {
    535548                        if (feature.type == Obj.CBLSUB) {
    536                                 Renderer.lineSymbols(feature, Areas.Cable, 0.0, null, null, 0, Symbols.Mline);
     549                                Renderer.lineSymbols(Areas.Cable, 0.0, null, null, 0, Symbols.Mline);
    537550                        } else if (feature.type == Obj.CBLOHD) {
    538551                                AttMap atts = feature.objs.get(Obj.CBLOHD).get(0);
    539552                                if ((atts != null) && (atts.containsKey(Att.CATCBL)) && (atts.get(Att.CATCBL).val == CatCBL.CBL_POWR)) {
    540                                         Renderer.lineSymbols(feature, Areas.CableDash, 0, Areas.CableDot, Areas.CableFlash, 2, Color.black);
     553                                        Renderer.lineSymbols(Areas.CableDash, 0, Areas.CableDot, Areas.CableFlash, 2, Color.black);
    541554                                } else {
    542                                         Renderer.lineSymbols(feature, Areas.CableDash, 0, Areas.CableDot, null, 2, Color.black);
     555                                        Renderer.lineSymbols(Areas.CableDash, 0, Areas.CableDot, null, 2, Color.black);
    543556                                }
    544557                                if (atts != null) {
    545558                                        if (atts.containsKey(Att.VERCLR)) {
    546                                                 Renderer.labelText(feature, String.valueOf((Double) atts.get(Att.VERCLR).val), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.VCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
     559                                                Renderer.labelText(String.valueOf((Double) atts.get(Att.VERCLR).val), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.VCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
    547560                                        } else if (atts.containsKey(Att.VERCSA)) {
    548                                                 Renderer.labelText(feature, String.valueOf((Double) atts.get(Att.VERCSA).val), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.PCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
     561                                                Renderer.labelText(String.valueOf((Double) atts.get(Att.VERCSA).val), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.PCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
    549562                                        }
    550563                                }
     
    556569                if (Renderer.zoom >= 14) {
    557570                        Symbol symb = Harbours.CallPoint2;
    558                         TrfTRF trf = (TrfTRF) getAttEnum(feature, feature.type, 0, Att.TRAFIC);
     571                        TrfTRF trf = (TrfTRF) getAttEnum(feature.type, Att.TRAFIC);
    559572                        if (trf != TrfTRF.TRF_TWOW) {
    560573                                symb = Harbours.CallPoint1;
    561574                        }
    562575                        Double orient = 0.0;
    563                         if ((orient = (Double) getAttVal(feature, feature.type, 0, Att.ORIENT)) == null) {
     576                        if ((orient = (Double) getAttVal(feature.type, Att.ORIENT)) == null) {
    564577                                orient = 0.0;
    565578                        }
    566                         Renderer.symbol(feature, symb, new Delta(Handle.CC, AffineTransform.getRotateInstance(Math.toRadians(orient))));
     579                        Renderer.symbol(symb, new Delta(Handle.CC, AffineTransform.getRotateInstance(Math.toRadians(orient))));
    567580                        String chn;
    568                         if (!(chn = getAttStr(feature, feature.type, 0, Att.COMCHA)).isEmpty()) {
    569                                 Renderer.labelText(feature, ("Ch." + chn), new Font("Arial", Font.PLAIN, 50), Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,50)));
     581                        if (!(chn = getAttStr(feature.type, Att.COMCHA)).isEmpty()) {
     582                                Renderer.labelText(("Ch." + chn), new Font("Arial", Font.PLAIN, 50), Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,50)));
    570583                        }
    571584                }
     
    574587        private static void distances() {
    575588                if (Renderer.zoom >= 14) {
    576                         if (!testAttribute(feature, Obj.DISMAR, 0, Att.CATDIS, CatDIS.DIS_NONI)) {
    577                                 Renderer.symbol(feature, Harbours.DistanceI);
     589                        if (!testAttribute(Obj.DISMAR, Att.CATDIS, CatDIS.DIS_NONI)) {
     590                                Renderer.symbol(Harbours.DistanceI);
    578591                        } else {
    579                                 Renderer.symbol(feature, Harbours.DistanceU);
     592                                Renderer.symbol(Harbours.DistanceU);
    580593                        }
    581594                        if (Renderer.zoom >= 15) {
    582                                 AttMap atts = getAtts(feature, Obj.DISMAR, 0);
     595                                AttMap atts = getAtts(Obj.DISMAR, 0);
    583596                                if ((atts != null) && (atts.containsKey(Att.WTWDIS))) {
    584597                                        Double dist = (Double) atts.get(Att.WTWDIS).val;
     
    609622                                        }
    610623                                        str += String.format("%1.0f", dist);
    611                                         Renderer.labelText(feature, str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.CC, AffineTransform.getTranslateInstance(0, 45)));
     624                                        Renderer.labelText(str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.CC, AffineTransform.getTranslateInstance(0, 45)));
    612625                                }
    613626                        }
     
    616629       
    617630        private static void floats() {
    618                 switch (feature.type) {
    619                 case LITVES:
    620                         Renderer.symbol(feature, Buoys.Super, getScheme(feature, feature.type));
    621                         break;
    622                 case LITFLT:
    623                         Renderer.symbol(feature, Buoys.Float, getScheme(feature, feature.type));
    624                         break;
    625                 case BOYINB:
    626                         Renderer.symbol(feature, Buoys.Super, getScheme(feature, feature.type));
    627                         break;
    628                 default:
    629                         break;
    630                 }
    631                 if (feature.objs.get(Obj.TOPMAR) != null)
    632                         Renderer.symbol(feature, Topmarks.Shapes.get(feature.objs.get(Obj.TOPMAR).get(0).get(Att.TOPSHP).val), getScheme(feature, Obj.TOPMAR), Topmarks.FloatDelta);
    633                 addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
    634                 Signals.addSignals(feature);
     631                if (Renderer.zoom >= 12) {
     632                        switch (feature.type) {
     633                        case LITVES:
     634                                Renderer.symbol(Buoys.Super, getScheme(feature.type));
     635                                break;
     636                        case LITFLT:
     637                                Renderer.symbol(Buoys.Float, getScheme(feature.type));
     638                                break;
     639                        case BOYINB:
     640                                Renderer.symbol(Buoys.Super, getScheme(feature.type));
     641                                break;
     642                        default:
     643                                break;
     644                        }
     645                        if (feature.objs.get(Obj.TOPMAR) != null)
     646                                Renderer.symbol(Topmarks.Shapes.get(feature.objs.get(Obj.TOPMAR).get(0).get(Att.TOPSHP).val), getScheme(Obj.TOPMAR), Topmarks.FloatDelta);
     647                        addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
     648                        Signals.addSignals();
     649                }
    635650        }
    636651       
    637652        private static void gauges() {
    638653                if (Renderer.zoom >= 14) {
    639                         Renderer.symbol(feature, Harbours.TideGauge);
    640                         addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
    641                         Signals.addSignals(feature);
     654                        Renderer.symbol(Harbours.TideGauge);
     655                        addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
     656                        Signals.addSignals();
    642657                }
    643658        }
     
    649664                case ACHBRT:
    650665                        if (Renderer.zoom >= 14) {
    651                                 Renderer.symbol(feature, Harbours.Anchorage, new Scheme(Symbols.Mline));
     666                                Renderer.symbol(Harbours.Anchorage, new Scheme(Symbols.Mline));
    652667                                if (Renderer.zoom >= 15) {
    653                                         Renderer.labelText(feature, name == null ? "" : name, new Font("Arial", Font.PLAIN, 30), Symbols.Msymb, LabelStyle.RRCT, Symbols.Mline, Color.white, new Delta(Handle.BC));
    654                                 }
    655                         }
    656                         if (getAttVal(feature, Obj.ACHBRT, 0, Att.RADIUS) != null) {
     668                                        Renderer.labelText(name == null ? "" : name, new Font("Arial", Font.PLAIN, 30), Symbols.Msymb, LabelStyle.RRCT, Symbols.Mline, Color.white, new Delta(Handle.BC));
     669                                }
     670                        }
     671                        if (getAttVal(Obj.ACHBRT, Att.RADIUS) != null) {
    657672                                double radius;
    658                                 if ((radius = (Double) getAttVal(feature, Obj.ACHBRT, 0, Att.RADIUS)) != 0) {
    659                                         UniHLU units = (UniHLU) getAttEnum(feature, Obj.ACHBRT, 0, Att.HUNITS);
     673                                if ((radius = (Double) getAttVal(Obj.ACHBRT, Att.RADIUS)) != 0) {
     674                                        UniHLU units = (UniHLU) getAttEnum(Obj.ACHBRT, Att.HUNITS);
    660675                                        if (units == UniHLU.HLU_UNKN) {
    661676                                                units = UniHLU.HLU_METR;
    662677                                        }
    663                                         Renderer.lineCircle(feature, new LineStyle(Symbols.Mline, 4, new float[] { 10, 10 }, null), radius, units);
     678                                        Renderer.lineCircle(new LineStyle(Symbols.Mline, 4, new float[] { 10, 10 }, null), radius, units);
    664679                                }
    665680                        }
     
    668683                        if (Renderer.zoom >= 12) {
    669684                                if (feature.geom.prim != Pflag.AREA) {
    670                                         Renderer.symbol(feature, Harbours.Anchorage, new Scheme(Color.black));
     685                                        Renderer.symbol(Harbours.Anchorage, new Scheme(Color.black));
    671686                                } else {
    672                                         Renderer.symbol(feature, Harbours.Anchorage, new Scheme(Symbols.Mline));
    673                                         Renderer.lineSymbols(feature, Areas.Restricted, 1.0, Areas.LineAnchor, null, 10, Symbols.Mline);
    674                                 }
    675                                 addName(feature, 15, new Font("Arial", Font.BOLD, 60), Symbols.Mline, new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, 0)));
    676                                 ArrayList<StsSTS> sts = (ArrayList<StsSTS>)getAttList(feature, Obj.ACHARE, 0, Att.STATUS);
     687                                        Renderer.symbol(Harbours.Anchorage, new Scheme(Symbols.Mline));
     688                                        Renderer.lineSymbols(Areas.Restricted, 1.0, Areas.LineAnchor, null, 10, Symbols.Mline);
     689                                }
     690                                addName(15, new Font("Arial", Font.BOLD, 60), Symbols.Mline, new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, 0)));
     691                                ArrayList<StsSTS> sts = (ArrayList<StsSTS>) getAttList(Obj.ACHARE, Att.STATUS);
    677692                                if ((Renderer.zoom >= 15) && (sts.contains(StsSTS.STS_RESV))) {
    678                                         Renderer.labelText(feature, "Reserved", new Font("Arial", Font.PLAIN, 50), Symbols.Mline, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, 60)));
    679                                 }
    680                         }
    681                         ArrayList<CatACH> cats = (ArrayList<CatACH>) getAttList(feature, Obj.ACHARE, 0, Att.CATACH);
    682                         int dy = (cats.size() - 1) * -30;
    683                         for (CatACH cat : cats) {
    684                                 switch (cat) {
    685                                 case ACH_DEEP:
    686                                         Renderer.labelText(feature, "DW", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
    687                                         dy += 60;
    688                                         break;
    689                                 case ACH_TANK:
    690                                         Renderer.labelText(feature, "Tanker", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
    691                                         dy += 60;
    692                                         break;
    693                                 case ACH_H24P:
    694                                         Renderer.labelText(feature, "24h", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
    695                                         dy += 60;
    696                                         break;
    697                                 case ACH_EXPL:
    698                                         Renderer.symbol(feature, Harbours.Explosives, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
    699                                         dy += 60;
    700                                         break;
    701                                 case ACH_QUAR:
    702                                         Renderer.symbol(feature, Harbours.Hospital, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
    703                                         dy += 60;
    704                                         break;
    705                                 case ACH_SEAP:
    706                                         Renderer.symbol(feature, Areas.Seaplane, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
    707                                         dy += 60;
    708                                         break;
    709                                 default:
     693                                        Renderer.labelText("Reserved", new Font("Arial", Font.PLAIN, 50), Symbols.Mline, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, 60)));
     694                                }
     695                                ArrayList<CatACH> cats = (ArrayList<CatACH>) getAttList(Obj.ACHARE, Att.CATACH);
     696                                int dy = (cats.size() - 1) * -30;
     697                                for (CatACH cat : cats) {
     698                                        switch (cat) {
     699                                        case ACH_DEEP:
     700                                                Renderer.labelText("DW", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
     701                                                dy += 60;
     702                                                break;
     703                                        case ACH_TANK:
     704                                                Renderer.labelText("Tanker", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
     705                                                dy += 60;
     706                                                break;
     707                                        case ACH_H24P:
     708                                                Renderer.labelText("24h", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
     709                                                dy += 60;
     710                                                break;
     711                                        case ACH_EXPL:
     712                                                Renderer.symbol(Harbours.Explosives, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
     713                                                dy += 60;
     714                                                break;
     715                                        case ACH_QUAR:
     716                                                Renderer.symbol(Harbours.Hospital, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
     717                                                dy += 60;
     718                                                break;
     719                                        case ACH_SEAP:
     720                                                Renderer.symbol(Areas.Seaplane, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
     721                                                dy += 60;
     722                                                break;
     723                                        default:
     724                                        }
    710725                                }
    711726                        }
     
    713728                case BERTHS:
    714729                        if (Renderer.zoom >= 14) {
    715                                 Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 6, new float[] { 20, 20 }));
    716                                 Renderer.labelText(feature, name == null ? " " : name, new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, LabelStyle.RRCT, Symbols.Mline, Color.white);
     730                                Renderer.lineVector(new LineStyle(Symbols.Mline, 6, new float[] { 20, 20 }));
     731                                Renderer.labelText(name == null ? " " : name, new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, LabelStyle.RRCT, Symbols.Mline, Color.white);
    717732                        }
    718733                        break;
     
    720735                        if (Renderer.zoom >= 16) {
    721736                                ArrayList<Symbol> symbols = new ArrayList<Symbol>();
    722                                 ArrayList<FncFNC> fncs = (ArrayList<FncFNC>) getAttList(feature, Obj.BUISGL, 0, Att.FUNCTN);
     737                                ArrayList<FncFNC> fncs = (ArrayList<FncFNC>) getAttList(Obj.BUISGL, Att.FUNCTN);
    723738                                for (FncFNC fnc : fncs) {
    724739                                        symbols.add(Landmarks.Funcs.get(fnc));
    725740                                }
    726741                                if (feature.objs.containsKey(Obj.SMCFAC)) {
    727                                         ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(feature, Obj.SMCFAC, 0, Att.CATSCF);
     742                                        ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(Obj.SMCFAC, Att.CATSCF);
    728743                                        for (CatSCF scf : scfs) {
    729744                                                symbols.add(Facilities.Cats.get(scf));
    730745                                        }
    731746                                }
    732                                 Renderer.cluster(feature, symbols);
     747                                Renderer.cluster(symbols);
    733748                        }
    734749                        break;
    735750                case HRBFAC:
    736751                        if (Renderer.zoom >= 12) {
    737                                 ArrayList<CatHAF> cathaf = (ArrayList<CatHAF>) getAttList(feature, Obj.HRBFAC, 0, Att.CATHAF);
     752                                ArrayList<CatHAF> cathaf = (ArrayList<CatHAF>) getAttList(Obj.HRBFAC, Att.CATHAF);
    738753                                if (cathaf.size() == 1) {
    739754                                        switch (cathaf.get(0)) {
    740755                                        case HAF_MRNA:
    741                                                 Renderer.symbol(feature, Harbours.Marina);
     756                                                Renderer.symbol(Harbours.Marina);
    742757                                                break;
    743758                                        case HAF_MANF:
    744                                                 Renderer.symbol(feature, Harbours.MarinaNF);
     759                                                Renderer.symbol(Harbours.MarinaNF);
    745760                                                break;
    746761                                        case HAF_FISH:
    747                                                 Renderer.symbol(feature, Harbours.Fishing);
     762                                                Renderer.symbol(Harbours.Fishing);
    748763                                                break;
    749764                                        default:
    750                                                 Renderer.symbol(feature, Harbours.Harbour);
     765                                                Renderer.symbol(Harbours.Harbour);
    751766                                                break;
    752767                                        }
    753768                                } else {
    754                                         Renderer.symbol(feature, Harbours.Harbour);
     769                                        Renderer.symbol(Harbours.Harbour);
    755770                                }
    756771                        }
     
    765780                switch (feature.type) {
    766781                case ROADWY:
    767                         ArrayList<CatROD> cat = (ArrayList<CatROD>) (getAttList(feature, Obj.ROADWY, 0, Att.CATROD));
     782                        ArrayList<CatROD> cat = (ArrayList<CatROD>) (getAttList(Obj.ROADWY, Att.CATROD));
    768783                        if (cat.size() > 0) {
    769784                                switch (cat.get(0)) {
    770785                                case ROD_MWAY:
    771                                         Renderer.lineVector(feature, new LineStyle(Color.black, 20));
     786                                        Renderer.lineVector(new LineStyle(Color.black, 20));
    772787                                        break;
    773788                                case ROD_MAJR:
    774                                         Renderer.lineVector(feature, new LineStyle(Color.black, 15));
     789                                        Renderer.lineVector(new LineStyle(Color.black, 15));
    775790                                        break;
    776791                                case ROD_MINR:
    777                                         Renderer.lineVector(feature, new LineStyle(Color.black, 10));
     792                                        Renderer.lineVector(new LineStyle(Color.black, 10));
    778793                                        break;
    779794                                default:
    780                                         Renderer.lineVector(feature, new LineStyle(Color.black, 5));
     795                                        Renderer.lineVector(new LineStyle(Color.black, 5));
    781796                                }
    782797                        } else {
    783                                 Renderer.lineVector(feature, new LineStyle(Color.black, 5));
     798                                Renderer.lineVector(new LineStyle(Color.black, 5));
    784799                        }
    785800                        break;
    786801                case RAILWY:
    787                         Renderer.lineVector(feature, new LineStyle(Color.gray, 10));
    788                         Renderer.lineVector(feature, new LineStyle(Color.black, 10, new float[] { 30, 30 }));
     802                        Renderer.lineVector(new LineStyle(Color.gray, 10));
     803                        Renderer.lineVector(new LineStyle(Color.black, 10, new float[] { 30, 30 }));
    789804                        break;
    790805                default:
     
    794809        @SuppressWarnings("unchecked")
    795810        private static void landmarks() {
    796                 ArrayList<CatLMK> cats = (ArrayList<CatLMK>) getAttList(feature, feature.type, 0, Att.CATLMK);
    797                 Symbol catSym = Landmarks.Shapes.get(cats.get(0));
    798                 ArrayList<FncFNC> fncs = (ArrayList<FncFNC>) getAttList(feature, feature.type, 0, Att.FUNCTN);
    799                 Symbol fncSym = Landmarks.Funcs.get(fncs.get(0));
    800                 if ((fncs.get(0) == FncFNC.FNC_CHCH) && (cats.get(0) == CatLMK.LMK_TOWR))
    801                         catSym = Landmarks.ChurchTower;
    802                 if ((cats.get(0) == CatLMK.LMK_UNKN) && (fncs.get(0) == FncFNC.FNC_UNKN) && (feature.objs.get(Obj.LIGHTS) != null))
    803                         catSym = Beacons.LightMajor;
    804                 if (cats.get(0) == CatLMK.LMK_RADR)
    805                         fncSym = Landmarks.RadioTV;
    806                 Renderer.symbol(feature, catSym);
    807                 Renderer.symbol(feature, fncSym);
    808                 addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
    809                 Signals.addSignals(feature);
    810         }
    811        
     811                if (Renderer.zoom >= 12) {
     812                        ArrayList<CatLMK> cats = (ArrayList<CatLMK>) getAttList(feature.type, Att.CATLMK);
     813                        Symbol catSym = Landmarks.Shapes.get(cats.get(0));
     814                        ArrayList<FncFNC> fncs = (ArrayList<FncFNC>) getAttList(feature.type, Att.FUNCTN);
     815                        Symbol fncSym = Landmarks.Funcs.get(fncs.get(0));
     816                        if ((fncs.get(0) == FncFNC.FNC_CHCH) && (cats.get(0) == CatLMK.LMK_TOWR))
     817                                catSym = Landmarks.ChurchTower;
     818                        if ((cats.get(0) == CatLMK.LMK_UNKN) && (fncs.get(0) == FncFNC.FNC_UNKN) && (feature.objs.get(Obj.LIGHTS) != null))
     819                                catSym = Beacons.LightMajor;
     820                        if (cats.get(0) == CatLMK.LMK_RADR)
     821                                fncSym = Landmarks.RadioTV;
     822                        Renderer.symbol(catSym);
     823                        Renderer.symbol(fncSym);
     824                        if (Renderer.zoom >= 15)
     825                                addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
     826                        Signals.addSignals();
     827                }
     828        }
     829       
     830        @SuppressWarnings("unchecked")
    812831        private static void lights() {
    813832                switch (feature.type) {
    814833                case LITMAJ:
    815                         Renderer.symbol(feature, Beacons.LightMajor);
     834                        Renderer.symbol(Beacons.LightMajor);
    816835                        break;
    817836                case LITMIN:
    818837                case LIGHTS:
    819                         Renderer.symbol(feature, Beacons.LightMinor);
     838                        Renderer.symbol(Beacons.LightMinor);
    820839                        break;
    821840                case PILPNT:
    822841                        if (feature.objs.containsKey(Obj.LIGHTS))
    823                                 Renderer.symbol(feature, Beacons.LightMinor);
     842                                Renderer.symbol(Beacons.LightMinor);
    824843                        else
    825                                 Renderer.symbol(feature, Harbours.Post);
     844                                Renderer.symbol(Harbours.Post);
    826845                        break;
    827846                default:
     
    829848                }
    830849                if (feature.objs.containsKey(Obj.TOPMAR)) {
    831                         Symbol topmark = Topmarks.Shapes.get(feature.objs.get(Obj.TOPMAR).get(0).get(Att.TOPSHP).val);
    832                         if (topmark != null)
    833                                 Renderer.symbol(feature, Topmarks.Shapes.get(feature.objs.get(Obj.TOPMAR).get(0).get(Att.TOPSHP).val), getScheme(feature, Obj.TOPMAR), Topmarks.LightDelta);
     850                        AttMap topmap = feature.objs.get(Obj.TOPMAR).get(0);
     851                        if (topmap.containsKey(Att.TOPSHP)) {
     852                                Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.TOPMAR), Topmarks.LightDelta);
     853                        }
    834854                } else  if (feature.objs.containsKey(Obj.DAYMAR)) {
    835                         Symbol topmark = Topmarks.Shapes.get(feature.objs.get(Obj.DAYMAR).get(0).get(Att.TOPSHP).val);
    836                         if (topmark != null)
    837                                 Renderer.symbol(feature, Topmarks.Shapes.get(feature.objs.get(Obj.DAYMAR).get(0).get(Att.TOPSHP).val), getScheme(feature, Obj.DAYMAR), Topmarks.LightDelta);
    838                 }
    839                 Signals.addSignals(feature);
     855                        AttMap topmap = feature.objs.get(Obj.DAYMAR).get(0);
     856                        if (topmap.containsKey(Att.TOPSHP)) {
     857                                Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.DAYMAR), Topmarks.LightDelta);
     858                        }
     859                }
     860                Signals.addSignals();
    840861        }
    841862
     
    844865                if (Renderer.zoom >= 16) {
    845866                        ArrayList<Symbol> symbols = new ArrayList<Symbol>();
    846                         ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(feature, Obj.SMCFAC, 0, Att.CATSCF);
     867                        ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(Obj.SMCFAC, Att.CATSCF);
    847868                        for (CatSCF scf : scfs) {
    848869                                symbols.add(Facilities.Cats.get(scf));
    849870                        }
    850                         Renderer.cluster(feature, symbols);
     871                        Renderer.cluster(symbols);
    851872                }
    852873        }
    853874       
    854875        private static void moorings() {
    855                 switch ((CatMOR) getAttEnum(feature, feature.type, 0, Att.CATMOR)) {
    856                 case MOR_DLPN:
    857                         Renderer.symbol(feature, Harbours.Dolphin);
    858                         break;
    859                 case MOR_DDPN:
    860                         Renderer.symbol(feature, Harbours.DeviationDolphin);
    861                         break;
    862                 case MOR_BLRD:
    863                 case MOR_POST:
    864                         Renderer.symbol(feature, Harbours.Bollard);
    865                         break;
    866                 case MOR_BUOY:
    867                         BoySHP shape = (BoySHP) getAttEnum(feature, feature.type, 0, Att.BOYSHP);
    868                         if (shape == BoySHP.BOY_UNKN) {
    869                                 shape = BoySHP.BOY_SPHR;
    870                         }
    871                         Renderer.symbol(feature, Buoys.Shapes.get(shape), getScheme(feature, feature.type));
    872                         Renderer.symbol(feature, Topmarks.TopMooring, Topmarks.BuoyDeltas.get(shape));
    873                         break;
    874                 default:
    875                         break;
    876                 }
    877                 Signals.addSignals(feature);
     876                if (Renderer.zoom >= 14) {
     877                        switch ((CatMOR) getAttEnum(feature.type, Att.CATMOR)) {
     878                        case MOR_DLPN:
     879                                Renderer.symbol(Harbours.Dolphin);
     880                                break;
     881                        case MOR_DDPN:
     882                                Renderer.symbol(Harbours.DeviationDolphin);
     883                                break;
     884                        case MOR_BLRD:
     885                        case MOR_POST:
     886                                Renderer.symbol(Harbours.Bollard);
     887                                break;
     888                        case MOR_BUOY:
     889                                BoySHP shape = (BoySHP) getAttEnum(feature.type, Att.BOYSHP);
     890                                if (shape == BoySHP.BOY_UNKN) {
     891                                        shape = BoySHP.BOY_SPHR;
     892                                }
     893                                Renderer.symbol(Buoys.Shapes.get(shape), getScheme(feature.type));
     894                                Renderer.symbol(Topmarks.TopMooring, Topmarks.BuoyDeltas.get(shape));
     895                                break;
     896                        default:
     897                                break;
     898                        }
     899                        Signals.addSignals();
     900                }
    878901        }
    879902
     
    902925                        int n = objs.size();
    903926                        if (n > 5) {
    904                                 Renderer.symbol(feature, Notices.Notice, new Delta(Handle.CC, AffineTransform.getTranslateInstance(dx, dy)));
     927                                Renderer.symbol(Notices.Notice, new Delta(Handle.CC, AffineTransform.getTranslateInstance(dx, dy)));
    905928                        } else {
    906929                                int i = 0;
     
    937960                                                break;
    938961                                        }
    939                                         if (h != null) Renderer.symbol(feature, sym, new Delta(h, AffineTransform.getTranslateInstance(dx, dy)));
     962                                        if (h != null) Renderer.symbol(sym, new Delta(h, AffineTransform.getTranslateInstance(dx, dy)));
    940963                                        i++;
    941964                                }
     
    946969        private static void obstructions() {
    947970                if ((Renderer.zoom >= 12) && (feature.type == Obj.OBSTRN)) {
    948                         switch ((CatOBS) getAttEnum(feature, feature.type, 0, Att.CATOBS)) {
     971                        switch ((CatOBS) getAttEnum(feature.type, Att.CATOBS)) {
    949972                        case OBS_BOOM:
    950                                 Renderer.lineVector(feature, new LineStyle(Color.black, 5, new float[] { 20, 20 }, null));
     973                                Renderer.lineVector(new LineStyle(Color.black, 5, new float[] { 20, 20 }, null));
    951974                                if (Renderer.zoom >= 15) {
    952                                         Renderer.lineText(feature, "Boom", new Font("Arial", Font.PLAIN, 80), Color.black, 0.5, -20);
     975                                        Renderer.lineText("Boom", new Font("Arial", Font.PLAIN, 80), Color.black, 0.5, -20);
    953976                                }
    954977                        default:
     
    957980                }
    958981                if ((Renderer.zoom >= 14) && (feature.type == Obj.UWTROC)) {
    959                         switch ((WatLEV) getAttEnum(feature, feature.type, 0, Att.WATLEV)) {
     982                        switch ((WatLEV) getAttEnum(feature.type, Att.WATLEV)) {
    960983                        case LEV_CVRS:
    961                                 Renderer.symbol(feature, Areas.RockC);
     984                                Renderer.symbol(Areas.RockC);
    962985                                break;
    963986                        case LEV_AWSH:
    964                                 Renderer.symbol(feature, Areas.RockA);
     987                                Renderer.symbol(Areas.RockA);
    965988                                break;
    966989                        default:
    967                                 Renderer.symbol(feature, Areas.Rock);
     990                                Renderer.symbol(Areas.Rock);
    968991                        }
    969992                } else {
    970                         Renderer.symbol(feature, Areas.Rock);
     993                        Renderer.symbol(Areas.Rock);
    971994                }
    972995        }
     
    975998                if ((Renderer.zoom >= 16) && (feature.geom.length < 2)) {
    976999                        if (feature.type == Obj.PIPSOL) {
    977                                 Renderer.lineSymbols(feature, Areas.Pipeline, 1.0, null, null, 0, Symbols.Mline);
     1000                                Renderer.lineSymbols(Areas.Pipeline, 1.0, null, null, 0, Symbols.Mline);
    9781001                        } else if (feature.type == Obj.PIPOHD) {
    979                                 Renderer.lineVector(feature, new LineStyle(Color.black, 8));
     1002                                Renderer.lineVector(new LineStyle(Color.black, 8));
    9801003                                AttMap atts = feature.atts;
    9811004                                double verclr = 0;
     
    9871010                                        }
    9881011                                        if (verclr > 0) {
    989                                                 Renderer.labelText(feature, String.valueOf(verclr), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.VCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
     1012                                                Renderer.labelText(String.valueOf(verclr), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.VCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
    9901013                                        }
    9911014                                }
     
    9961019        @SuppressWarnings("unchecked")
    9971020        private static void platforms() {
    998                 ArrayList<CatOFP> cats = (ArrayList<CatOFP>) getAttList(feature, Obj.OFSPLF, 0, Att.CATOFP);
     1021                ArrayList<CatOFP> cats = (ArrayList<CatOFP>) getAttList(Obj.OFSPLF, Att.CATOFP);
    9991022                if ((CatOFP) cats.get(0) == CatOFP.OFP_FPSO)
    1000                         Renderer.symbol(feature, Buoys.Storage);
     1023                        Renderer.symbol(Buoys.Storage);
    10011024                else
    1002                         Renderer.symbol(feature, Landmarks.Platform);
    1003                 addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
    1004                 Signals.addSignals(feature);
     1025                        Renderer.symbol(Landmarks.Platform);
     1026                addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
     1027                Signals.addSignals();
    10051028        }
    10061029
     
    10081031                if (Renderer.zoom >= 14) {
    10091032                        if (feature.type == Obj.CRANES) {
    1010                                 if ((CatCRN) getAttEnum(feature, feature.type, 0, Att.CATCRN) == CatCRN.CRN_CONT)
    1011                                         Renderer.symbol(feature, Harbours.ContainerCrane);
     1033                                if ((CatCRN) getAttEnum(feature.type, Att.CATCRN) == CatCRN.CRN_CONT)
     1034                                        Renderer.symbol(Harbours.ContainerCrane);
    10121035                                else
    1013                                         Renderer.symbol(feature, Harbours.PortCrane);
     1036                                        Renderer.symbol(Harbours.PortCrane);
    10141037                        } else if (feature.type == Obj.HULKES) {
    1015                                 Renderer.lineVector(feature, new LineStyle(Color.black, 4, null, new Color(0xffe000)));
    1016                                 addName(feature, 15, new Font("Arial", Font.BOLD, 40));
     1038                                Renderer.lineVector(new LineStyle(Color.black, 4, null, new Color(0xffe000)));
     1039                                addName(15, new Font("Arial", Font.BOLD, 40));
    10171040                        }
    10181041                }
     
    10251048                case TSSRON:
    10261049                        if (Renderer.zoom <= 15)
    1027                                 Renderer.lineVector(feature, new LineStyle(Symbols.Mline));
     1050                                Renderer.lineVector(new LineStyle(Symbols.Mtss));
    10281051                        else
    1029                                 Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 20, null, null));
    1030                         addName(feature, 10, new Font("Arial", Font.BOLD, 150), Symbols.Mline);
     1052                                Renderer.lineVector(new LineStyle(Symbols.Mtss, 20, null, null));
     1053                        addName(10, new Font("Arial", Font.BOLD, 150), Symbols.Mline);
    10311054                        break;
    10321055                case TSELNE:
    1033                         Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 20, null, null));
     1056                        Renderer.lineVector(new LineStyle(Symbols.Mtss, 20, null, null));
    10341057                        break;
    10351058                case TSSLPT:
    1036                         Renderer.lineSymbols(feature, Areas.LaneArrow, 0.5, null, null, 0, Symbols.Mline);
     1059                        Renderer.lineSymbols(Areas.LaneArrow, 0.5, null, null, 0, Symbols.Mtss);
    10371060                        break;
    10381061                case TSSBND:
    1039                         Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 20, new float[] { 40, 40 }, null));
     1062                        Renderer.lineVector(new LineStyle(Symbols.Mtss, 20, new float[] { 40, 40 }, null));
    10401063                        break;
    10411064                case ISTZNE:
    1042                         Renderer.lineSymbols(feature, Areas.Restricted, 1.0, null, null, 0, Symbols.Mline);
     1065                        Renderer.lineSymbols(Areas.Restricted, 1.0, null, null, 0, Symbols.Mtss);
    10431066                        break;
    10441067                default:
     
    10491072        @SuppressWarnings("unchecked")
    10501073        private static void shoreline() {
    1051                 CatSLC cat = (CatSLC) getAttEnum(feature, feature.type, 0, Att.CATSLC);
     1074                CatSLC cat = (CatSLC) getAttEnum(feature.type, Att.CATSLC);
    10521075                if ((Renderer.context.ruleset() == RuleSet.ALL) || (Renderer.context.ruleset() == RuleSet.BASE)) {
    10531076                        if ((cat != CatSLC.SLC_SWAY) && (cat != CatSLC.SLC_TWAL)) {
    10541077                                if (Renderer.zoom >= 12) {
    1055                                         Renderer.lineVector(feature, new LineStyle(Color.black, 10, Symbols.Yland));
     1078                                        Renderer.lineVector(new LineStyle(Color.black, 10, Symbols.Yland));
    10561079                                } else {
    1057                                         Renderer.lineVector(feature, new LineStyle(Symbols.Yland));
     1080                                        Renderer.lineVector(new LineStyle(Symbols.Yland));
    10581081                                }
    10591082                        }
     
    10631086                                switch (cat) {
    10641087                                case SLC_TWAL:
    1065                                         WatLEV lev = (WatLEV) getAttEnum(feature, feature.type, 0, Att.WATLEV);
     1088                                        WatLEV lev = (WatLEV) getAttEnum(feature.type, Att.WATLEV);
    10661089                                        if (lev == WatLEV.LEV_CVRS) {
    1067                                                 Renderer.lineVector(feature, new LineStyle(Color.black, 10, new float[] { 40, 40 }, null));
     1090                                                Renderer.lineVector(new LineStyle(Color.black, 10, new float[] { 40, 40 }, null));
    10681091                                                if (Renderer.zoom >= 15)
    1069                                                         Renderer.lineText(feature, "(covers)", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, 80);
     1092                                                        Renderer.lineText("(covers)", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, 80);
    10701093                                        } else {
    1071                                                 Renderer.lineVector(feature, new LineStyle(Color.black, 10, null, null));
     1094                                                Renderer.lineVector(new LineStyle(Color.black, 10, null, null));
    10721095                                        }
    10731096                                        if (Renderer.zoom >= 15)
    1074                                                 Renderer.lineText(feature, "Training Wall", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, -30);
     1097                                                Renderer.lineText("Training Wall", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, -30);
    10751098                                        break;
    10761099                                case SLC_SWAY:
    1077                                         Renderer.lineVector(feature, new LineStyle(Color.black, 2, null, new Color(0xffe000)));
     1100                                        Renderer.lineVector(new LineStyle(Color.black, 2, null, new Color(0xffe000)));
    10781101                                        if ((Renderer.zoom >= 16) && feature.objs.containsKey(Obj.SMCFAC)) {
    10791102                                                ArrayList<Symbol> symbols = new ArrayList<Symbol>();
    1080                                                 ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(feature, Obj.SMCFAC, 0, Att.CATSCF);
     1103                                                ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(Obj.SMCFAC, Att.CATSCF);
    10811104                                                for (CatSCF scf : scfs) {
    10821105                                                        symbols.add(Facilities.Cats.get(scf));
    10831106                                                }
    1084                                                 Renderer.cluster(feature, symbols);
     1107                                                Renderer.cluster(symbols);
    10851108                                        }
    10861109                                        break;
     
    10981121                        switch (feature.type) {
    10991122                        case SISTAT:
    1100                                 Renderer.symbol(feature, Harbours.SignalStation);
     1123                                Renderer.symbol(Harbours.SignalStation);
    11011124                                str = "SS";
    1102                                 ArrayList<CatSIT> tcats = (ArrayList<CatSIT>) getAttList(feature, Obj.SISTAT, 0, Att.CATSIT);
     1125                                ArrayList<CatSIT> tcats = (ArrayList<CatSIT>) getAttList(Obj.SISTAT, Att.CATSIT);
    11031126                                switch (tcats.get(0)) {
    11041127                                case SIT_IPT:
     
    11221145                                break;
    11231146                        case SISTAW:
    1124                                 Renderer.symbol(feature, Harbours.SignalStation);
     1147                                Renderer.symbol(Harbours.SignalStation);
    11251148                                str = "SS";
    11261149                                str = "SS";
    1127                                 ArrayList<CatSIW> wcats = (ArrayList<CatSIW>) getAttList(feature, Obj.SISTAW, 0, Att.CATSIW);
     1150                                ArrayList<CatSIW> wcats = (ArrayList<CatSIW>) getAttList(Obj.SISTAW, Att.CATSIW);
    11281151                                switch (wcats.get(0)) {
    11291152                                case SIW_STRM:
     
    11631186                        case RDOSTA:
    11641187                        case RTPBCN:
    1165                                 Renderer.symbol(feature, Harbours.SignalStation);
    1166                                 Renderer.symbol(feature, Beacons.RadarStation);
     1188                                Renderer.symbol(Harbours.SignalStation);
     1189                                Renderer.symbol(Beacons.RadarStation);
     1190                                break;
     1191                        case RADRFL:
     1192                                Renderer.symbol(Topmarks.RadarReflector);
    11671193                                break;
    11681194                        case RADSTA:
    1169                                 Renderer.symbol(feature, Harbours.SignalStation);
    1170                                 Renderer.symbol(feature, Beacons.RadarStation);
    1171                                 Renderer.labelText(feature, "Ra", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-30, -70)));
     1195                                Renderer.symbol(Harbours.SignalStation);
     1196                                Renderer.symbol(Beacons.RadarStation);
     1197                                Renderer.labelText("Ra", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-30, -70)));
    11721198                                break;
    11731199                        case PILBOP:
    1174                                 Renderer.symbol(feature, Harbours.Pilot);
    1175                                 addName(feature, 15, new Font("Arial", Font.BOLD, 40), Symbols.Msymb , new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, -40)));
    1176                                 CatPIL cat = (CatPIL) getAttEnum(feature, feature.type, 0, Att.CATPIL);
     1200                                Renderer.symbol(Harbours.Pilot);
     1201                                addName(15, new Font("Arial", Font.BOLD, 40), Symbols.Msymb , new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, -40)));
     1202                                CatPIL cat = (CatPIL) getAttEnum(feature.type, Att.CATPIL);
    11771203                                if (cat == CatPIL.PIL_HELI) {
    1178                                         Renderer.labelText(feature, "H", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, 0)));
     1204                                        Renderer.labelText("H", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, 0)));
    11791205                                }
    11801206                                break;
    11811207                        case CGUSTA:
    1182                                 Renderer.symbol(feature, Harbours.SignalStation);
     1208                                Renderer.symbol(Harbours.SignalStation);
    11831209                                str = "CG";
    1184                           if (feature.objs.containsKey(Obj.RSCSTA)) Renderer.symbol(feature, Harbours.Rescue, new Delta(Handle.CC, AffineTransform.getTranslateInstance(130, 0)));
     1210                          if (feature.objs.containsKey(Obj.RSCSTA)) Renderer.symbol(Harbours.Rescue, new Delta(Handle.CC, AffineTransform.getTranslateInstance(130, 0)));
    11851211                                break;
    11861212                        case RSCSTA:
    1187                                 Renderer.symbol(feature, Harbours.Rescue);
     1213                                Renderer.symbol(Harbours.Rescue);
    11881214                                break;
    11891215                        default:
     
    11911217                        }
    11921218                        if ((Renderer.zoom >= 15) && !str.isEmpty()) {
    1193                                 Renderer.labelText(feature, str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.LC, AffineTransform.getTranslateInstance(40, 0)));
    1194                         }
    1195                         Signals.addSignals(feature);
     1219                                Renderer.labelText(str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.LC, AffineTransform.getTranslateInstance(40, 0)));
     1220                        }
     1221                        Signals.addSignals();
    11961222                }
    11971223        }
     
    11991225        private static void transits() {
    12001226          if (Renderer.zoom >= 14) {
    1201                 if (feature.type == Obj.RECTRC) Renderer.lineVector (feature, new LineStyle(Color.black, 10, null, null));
    1202                 else if (feature.type == Obj.NAVLNE) Renderer.lineVector (feature, new LineStyle(Color.black, 10, new float[] { 25, 25 }, null));
     1227                if (feature.type == Obj.RECTRC) Renderer.lineVector (new LineStyle(Color.black, 10, null, null));
     1228                else if (feature.type == Obj.NAVLNE) Renderer.lineVector (new LineStyle(Color.black, 10, new float[] { 25, 25 }, null));
    12031229          }
    12041230                if (Renderer.zoom >= 15) {
     
    12081234                                str += name + " ";
    12091235                        Double ort;
    1210                         if ((ort = (Double) getAttVal(feature, feature.type, 0, Att.ORIENT)) != null) {
    1211                                 str += ort.toString() + "\u0152";
     1236                        if ((ort = (Double) getAttVal(feature.type, Att.ORIENT)) != null) {
     1237                                str += df.format(ort) + "º";
    12121238                                if (!str.isEmpty())
    1213                                         Renderer.lineText(feature, str, new Font("Arial", Font.PLAIN, 80), Color.black, 0.5, -20);
     1239                                        Renderer.lineText(str, new Font("Arial", Font.PLAIN, 80), Color.black, 0.5, -20);
    12141240                        }
    12151241                }
     
    12171243
    12181244        private static void waterways() {
    1219                 Renderer.lineVector(feature, new LineStyle(Symbols.Bwater, 20, (feature.geom.prim == Pflag.AREA) ? Symbols.Bwater : null));
     1245                Renderer.lineVector(new LineStyle(Symbols.Bwater, 20, (feature.geom.prim == Pflag.AREA) ? Symbols.Bwater : null));
    12201246        }
    12211247
    12221248        private static void wrecks() {
    12231249                if (Renderer.zoom >= 14) {
    1224                         switch ((CatWRK) getAttEnum(feature, feature.type, 0, Att.CATWRK)) {
     1250                        switch ((CatWRK) getAttEnum(feature.type, Att.CATWRK)) {
    12251251                        case WRK_DNGR:
    12261252                        case WRK_MSTS:
    1227                                 Renderer.symbol(feature, Areas.WreckD);
     1253                                Renderer.symbol(Areas.WreckD);
    12281254                                break;
    12291255                        case WRK_HULS:
    1230                                 Renderer.symbol(feature, Areas.WreckS);
     1256                                Renderer.symbol(Areas.WreckS);
    12311257                                break;
    12321258                        default:
    1233                                 Renderer.symbol(feature, Areas.WreckND);
     1259                                Renderer.symbol(Areas.WreckND);
    12341260                        }
    12351261                }
Note: See TracChangeset for help on using the changeset viewer.