source: osm/applications/editors/josm/plugins/smed/src/seamarks/SeaMark.java@ 33178

Last change on this file since 33178 was 33178, checked in by donvip, 9 years ago

fix errors with error_prone
  • Property svn:executable set to *
File size: 107.9 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package seamarks;
3
4import java.awt.BasicStroke;
5import java.awt.Color;
6import java.awt.Graphics;
7import java.awt.Graphics2D;
8import java.awt.RenderingHints;
9import java.awt.geom.Arc2D;
10import java.util.ArrayList;
11import java.util.EnumMap;
12import java.util.EnumSet;
13import java.util.HashMap;
14import java.util.Map;
15
16import javax.swing.ImageIcon;
17import javax.swing.JPanel;
18
19import org.openstreetmap.josm.Main;
20import org.openstreetmap.josm.command.ChangePropertyCommand;
21import org.openstreetmap.josm.data.osm.OsmPrimitive;
22
23import messages.Messages;
24import panels.PanelMain;
25import smed.SmedAction;
26
27public class SeaMark extends JPanel {
28
29 public SmedAction dlg = null;
30
31 public SeaMark(SmedAction dia) {
32 dlg = dia;
33 clrLight();
34 }
35
36 public enum Reg {
37 A, B, C, R, X
38 }
39
40 public static final EnumMap<Reg, String> RegSTR = new EnumMap<>(Reg.class);
41 static {
42 RegSTR.put(Reg.A, "iala-a");
43 RegSTR.put(Reg.B, "iala-b");
44 RegSTR.put(Reg.C, "cevni");
45 RegSTR.put(Reg.R, "riwr");
46 RegSTR.put(Reg.X, "other");
47 }
48
49 private Reg region = Reg.A;
50
51 public Reg getRegion() {
52 return region;
53 }
54
55 public void setRegion(Reg reg) {
56 region = reg;
57 }
58
59 private String name = "";
60
61 @Override
62 public String getName() {
63 return name;
64 }
65
66 @Override
67 public void setName(String str) {
68 name = str.trim();
69 repaint();
70 }
71
72 public enum Obj {
73 UNKOBJ, BCNCAR, BCNISD, BCNLAT, BCNSAW, BCNSPP,
74 BOYCAR, BOYISD, BOYLAT, BOYSAW, BOYSPP, NOTMRK,
75 FLTCAR, FLTISD, FLTLAT, FLTSAW, FLTSPP,
76 LITMAJ, LITMIN, LITFLT, LITVES, LITHSE, LNDMRK,
77 MORFAC, BOYINB, SISTAW, SISTAT, OFSPLF,
78 CGUSTA, PILBOP, RSCSTA, RDOSTA, RADSTA
79 }
80
81 public static final EnumMap<Obj, String> ObjSTR = new EnumMap<>(Obj.class);
82 static {
83 ObjSTR.put(Obj.BCNCAR, "beacon_cardinal");
84 ObjSTR.put(Obj.BCNISD, "beacon_isolated_danger");
85 ObjSTR.put(Obj.BCNLAT, "beacon_lateral");
86 ObjSTR.put(Obj.BCNSAW, "beacon_safe_water");
87 ObjSTR.put(Obj.BCNSPP, "beacon_special_purpose");
88 ObjSTR.put(Obj.BOYCAR, "buoy_cardinal");
89 ObjSTR.put(Obj.BOYISD, "buoy_isolated_danger");
90 ObjSTR.put(Obj.BOYLAT, "buoy_lateral");
91 ObjSTR.put(Obj.BOYSAW, "buoy_safe_water");
92 ObjSTR.put(Obj.BOYSPP, "buoy_special_purpose");
93 ObjSTR.put(Obj.FLTCAR, "light_float");
94 ObjSTR.put(Obj.FLTLAT, "light_float");
95 ObjSTR.put(Obj.FLTSAW, "light_float");
96 ObjSTR.put(Obj.FLTISD, "light_float");
97 ObjSTR.put(Obj.FLTSPP, "light_float");
98 ObjSTR.put(Obj.LITMAJ, "light_major");
99 ObjSTR.put(Obj.LITMIN, "light_minor");
100 ObjSTR.put(Obj.LITFLT, "light_float");
101 ObjSTR.put(Obj.LITVES, "light_vessel");
102 ObjSTR.put(Obj.NOTMRK, "notice");
103 ObjSTR.put(Obj.LNDMRK, "landmark");
104 ObjSTR.put(Obj.LITHSE, "landmark");
105 ObjSTR.put(Obj.MORFAC, "mooring");
106 ObjSTR.put(Obj.BOYINB, "buoy_installation");
107 ObjSTR.put(Obj.OFSPLF, "platform");
108 ObjSTR.put(Obj.SISTAW, "signal_station_warning");
109 ObjSTR.put(Obj.SISTAT, "signal_station_traffic");
110 ObjSTR.put(Obj.CGUSTA, "coastguard_station");
111 ObjSTR.put(Obj.PILBOP, "pilot_boarding");
112 ObjSTR.put(Obj.RSCSTA, "rescue_station");
113 ObjSTR.put(Obj.RDOSTA, "radio_station");
114 ObjSTR.put(Obj.RADSTA, "radar_station");
115 }
116
117 private Obj object = Obj.UNKOBJ;
118
119 public Obj getObject() {
120 return object;
121 }
122
123 public void setObject(Obj obj) {
124 object = obj;
125 if (obj == Obj.UNKOBJ) {
126 setCategory(Cat.NOCAT);
127 setFunc(Fnc.UNKFNC);
128 setShape(Shp.UNKSHP);
129 setColour(Ent.BODY, Col.UNKCOL);
130 setPattern(Ent.BODY, Pat.NOPAT);
131 setTopmark(Top.NOTOP);
132 setColour(Ent.TOPMARK, Col.UNKCOL);
133 setPattern(Ent.TOPMARK, Pat.NOPAT);
134 }
135 repaint();
136 }
137
138 public enum Ent {
139 BODY, BUOY, BEACON, LFLOAT, TOPMARK, LIGHT, MOORING, STATION, PLATFORM, NOTICE
140 }
141
142 public static final EnumMap<Obj, Ent> EntMAP = new EnumMap<>(Obj.class);
143 static {
144 EntMAP.put(Obj.BCNCAR, Ent.BEACON);
145 EntMAP.put(Obj.BCNISD, Ent.BEACON);
146 EntMAP.put(Obj.BCNLAT, Ent.BEACON);
147 EntMAP.put(Obj.BCNSAW, Ent.BEACON);
148 EntMAP.put(Obj.BCNSPP, Ent.BEACON);
149 EntMAP.put(Obj.BOYCAR, Ent.BUOY);
150 EntMAP.put(Obj.BOYISD, Ent.BUOY);
151 EntMAP.put(Obj.BOYLAT, Ent.BUOY);
152 EntMAP.put(Obj.BOYSAW, Ent.BUOY);
153 EntMAP.put(Obj.BOYSPP, Ent.BUOY);
154 EntMAP.put(Obj.LITMAJ, Ent.LIGHT);
155 EntMAP.put(Obj.LITMIN, Ent.LIGHT);
156 EntMAP.put(Obj.LITFLT, Ent.LFLOAT);
157 EntMAP.put(Obj.FLTCAR, Ent.LFLOAT);
158 EntMAP.put(Obj.FLTLAT, Ent.LFLOAT);
159 EntMAP.put(Obj.FLTSAW, Ent.LFLOAT);
160 EntMAP.put(Obj.FLTISD, Ent.LFLOAT);
161 EntMAP.put(Obj.FLTSPP, Ent.LFLOAT);
162 EntMAP.put(Obj.LITVES, Ent.LFLOAT);
163 EntMAP.put(Obj.LITHSE, Ent.LIGHT);
164 EntMAP.put(Obj.LNDMRK, Ent.LIGHT);
165 EntMAP.put(Obj.MORFAC, Ent.MOORING);
166 EntMAP.put(Obj.BOYINB, Ent.MOORING);
167 EntMAP.put(Obj.OFSPLF, Ent.PLATFORM);
168 EntMAP.put(Obj.SISTAW, Ent.STATION);
169 EntMAP.put(Obj.SISTAT, Ent.STATION);
170 EntMAP.put(Obj.CGUSTA, Ent.STATION);
171 EntMAP.put(Obj.PILBOP, Ent.STATION);
172 EntMAP.put(Obj.RSCSTA, Ent.STATION);
173 EntMAP.put(Obj.RDOSTA, Ent.STATION);
174 EntMAP.put(Obj.RADSTA, Ent.STATION);
175 EntMAP.put(Obj.NOTMRK, Ent.NOTICE);
176 }
177
178 public enum Grp {
179 NUL, LAT, CAR, SAW, ISD, SPP, LGT, STN, PLF, NTC
180 }
181
182 public static final EnumMap<Obj, Grp> GrpMAP = new EnumMap<>(Obj.class);
183 static {
184 GrpMAP.put(Obj.UNKOBJ, Grp.NUL);
185 GrpMAP.put(Obj.BCNCAR, Grp.CAR);
186 GrpMAP.put(Obj.BCNISD, Grp.ISD);
187 GrpMAP.put(Obj.BCNLAT, Grp.LAT);
188 GrpMAP.put(Obj.BCNSAW, Grp.SAW);
189 GrpMAP.put(Obj.BCNSPP, Grp.SPP);
190 GrpMAP.put(Obj.BOYCAR, Grp.CAR);
191 GrpMAP.put(Obj.BOYISD, Grp.ISD);
192 GrpMAP.put(Obj.BOYLAT, Grp.LAT);
193 GrpMAP.put(Obj.BOYSAW, Grp.SAW);
194 GrpMAP.put(Obj.BOYSPP, Grp.SPP);
195 GrpMAP.put(Obj.FLTCAR, Grp.CAR);
196 GrpMAP.put(Obj.FLTLAT, Grp.LAT);
197 GrpMAP.put(Obj.FLTSAW, Grp.SAW);
198 GrpMAP.put(Obj.FLTISD, Grp.ISD);
199 GrpMAP.put(Obj.FLTSPP, Grp.SPP);
200 GrpMAP.put(Obj.LITFLT, Grp.LGT);
201 GrpMAP.put(Obj.LITMAJ, Grp.LGT);
202 GrpMAP.put(Obj.LITMIN, Grp.LGT);
203 GrpMAP.put(Obj.LITVES, Grp.LGT);
204 GrpMAP.put(Obj.LITHSE, Grp.LGT);
205 GrpMAP.put(Obj.LNDMRK, Grp.LGT);
206 GrpMAP.put(Obj.MORFAC, Grp.SPP);
207 GrpMAP.put(Obj.BOYINB, Grp.SPP);
208 GrpMAP.put(Obj.OFSPLF, Grp.PLF);
209 GrpMAP.put(Obj.SISTAW, Grp.STN);
210 GrpMAP.put(Obj.SISTAT, Grp.STN);
211 GrpMAP.put(Obj.CGUSTA, Grp.STN);
212 GrpMAP.put(Obj.PILBOP, Grp.STN);
213 GrpMAP.put(Obj.RSCSTA, Grp.STN);
214 GrpMAP.put(Obj.RDOSTA, Grp.STN);
215 GrpMAP.put(Obj.RADSTA, Grp.STN);
216 GrpMAP.put(Obj.NOTMRK, Grp.NTC);
217 }
218
219 public enum Cat {
220 NOCAT, LAM_PORT, LAM_STBD, LAM_PPORT, LAM_PSTBD, CAM_NORTH, CAM_EAST, CAM_SOUTH, CAM_WEST,
221 ACH_URST, ACH_DEEP, ACH_TANK, ACH_EXPL, ACH_QUAR, ACH_SPLN, ACH_SCAN, ACH_SCMO, ACH_T24H, ACH_TLIM,
222 SPM_UNKN, SPM_WARN, SPM_CHBF, SPM_YCHT, SPM_CABL, SPM_OFAL, SPM_ODAS, SPM_RECN, SPM_MOOR, SPM_LNBY,
223 SPM_LDNG, SPM_NOTC, SPM_TSS, SPM_FOUL, SPM_DIVE, SPM_FRRY, SPM_ANCH,
224 MOR_DLPN, MOR_DDPN, MOR_BLRD, MOR_WALL, MOR_POST, MOR_CHWR, MOR_ROPE, MOR_AUTO, MOR_BUOY, INB_CALM, INB_SBM,
225 SIS_PTCL, SIS_PTED, SIS_IPT, SIS_BRTH, SIS_DOCK, SIS_LOCK, SIS_FBAR, SIS_BRDG, SIS_DRDG, SIS_TRFC,
226 SIS_DNGR, SIS_OBST, SIS_CABL, SIS_MILY, SIS_DSTR, SIS_WTHR, SIS_STRM, SIS_ICE, SIS_TIME, SIS_TIDE,
227 SIS_TSTM, SIS_TGAG, SIS_TSCL, SIS_DIVE, SIS_LGAG, LIT_DIRF, LIT_LEDG,
228 LMK_CHMY, LMK_CARN, LMK_DSHA, LMK_FLGS, LMK_FLRS, LMK_MNMT, LMK_TOWR, LMK_WNDM, LMK_WTRT, LMK_MNRT,
229 LMK_MAST, LMK_WNDS, LMK_CLMN, LMK_OBLK, LMK_STAT, LMK_CROS, LMK_DOME, LMK_SCNR, LMK_WNDL, LMK_SPIR,
230 OFP_OIL, OFP_PRD, OFP_OBS, OFP_ALP, OFP_SALM, OFP_MOR, OFP_ISL, OFP_FPSO, OFP_ACC, OFP_NCCB,
231 RSC_LFB, RSC_RKT, RSC_RSW, RSC_RIT, RSC_MLB, RSC_RAD, RSC_FAE, RSC_SPL, RSC_AIR, RSC_TUG,
232 RAS_SRV, RAS_CST, PIL_VESS, PIL_HELI, PIL_SHORE,
233 NTC_A1, NTC_A1a, NTC_A2, NTC_A3, NTC_A4, NTC_A4_1, NTC_A5, NTC_A5_1, NTC_A6, NTC_A7, NTC_A8, NTC_A9,
234 NTC_A10a, NTC_A10b, NTC_A12, NTC_A13, NTC_A14, NTC_A15, NTC_A16, NTC_A17, NTC_A18, NTC_A19, NTC_A20,
235 NTC_B1a, NTC_B1b, NTC_B2a, NTC_B2b, NTC_B3a, NTC_B3b, NTC_B4a, NTC_B4b, NTC_B5, NTC_B6, NTC_B7, NTC_B8, NTC_B9a, NTC_B9b, NTC_B11,
236 NTC_C1, NTC_C2, NTC_C3, NTC_C4, NTC_C5a, NTC_C5b, NTC_D1a, NTC_D1b, NTC_D2a, NTC_D2b, NTC_D3a, NTC_D3b,
237 NOROS, ROS_UNKN, ROS_OMNI, ROS_DIRL, ROS_ROTP, ROS_CNSL, ROS_RDF, ROS_QTG, ROS_AERO, ROS_DECA, ROS_LORN,
238 ROS_DGPS, ROS_TORN, ROS_OMGA, ROS_SYLD, ROS_CHKA,
239 ROS_PCOM, ROS_COMB, ROS_FACS, ROS_TIME, ROS_PAIS, ROS_SAIS, ROS_VAIS, ROS_VANC, ROS_VASC, ROS_VAEC, ROS_VAWC,
240 ROS_VAPL, ROS_VASL, ROS_VAID, ROS_VASW, ROS_VASP, ROS_VAWK
241 }
242
243 public static final EnumMap<Cat, String> CatSTR = new EnumMap<>(Cat.class);
244 static {
245 CatSTR.put(Cat.LAM_PORT, "port");
246 CatSTR.put(Cat.LAM_STBD, "starboard");
247 CatSTR.put(Cat.LAM_PPORT, "preferred_channel_port");
248 CatSTR.put(Cat.LAM_PSTBD, "preferred_channel_starboard");
249 CatSTR.put(Cat.CAM_NORTH, "north");
250 CatSTR.put(Cat.CAM_EAST, "east");
251 CatSTR.put(Cat.CAM_SOUTH, "south");
252 CatSTR.put(Cat.CAM_WEST, "west");
253 CatSTR.put(Cat.SPM_UNKN, "unknown_purpose");
254 CatSTR.put(Cat.SPM_WARN, "warning");
255 CatSTR.put(Cat.SPM_CHBF, "channel_separation");
256 CatSTR.put(Cat.SPM_YCHT, "yachting");
257 CatSTR.put(Cat.SPM_CABL, "cable");
258 CatSTR.put(Cat.SPM_OFAL, "outfall");
259 CatSTR.put(Cat.SPM_ODAS, "odas");
260 CatSTR.put(Cat.SPM_RECN, "recreation_zone");
261 CatSTR.put(Cat.SPM_MOOR, "mooring");
262 CatSTR.put(Cat.SPM_LNBY, "lanby");
263 CatSTR.put(Cat.SPM_LDNG, "leading");
264 CatSTR.put(Cat.SPM_NOTC, "notice");
265 CatSTR.put(Cat.SPM_TSS, "tss");
266 CatSTR.put(Cat.SPM_FOUL, "foul_ground");
267 CatSTR.put(Cat.SPM_DIVE, "diving");
268 CatSTR.put(Cat.SPM_FRRY, "ferry_crossing");
269 CatSTR.put(Cat.SPM_ANCH, "anchorage");
270 CatSTR.put(Cat.MOR_DLPN, "dolphin");
271 CatSTR.put(Cat.MOR_DDPN, "deviation_dolphin");
272 CatSTR.put(Cat.MOR_BLRD, "bollard");
273 CatSTR.put(Cat.MOR_WALL, "wall");
274 CatSTR.put(Cat.MOR_POST, "post");
275 CatSTR.put(Cat.MOR_CHWR, "chain");
276 CatSTR.put(Cat.MOR_ROPE, "shore_rope");
277 CatSTR.put(Cat.MOR_AUTO, "automatic");
278 CatSTR.put(Cat.MOR_BUOY, "buoy");
279 CatSTR.put(Cat.INB_CALM, "calm");
280 CatSTR.put(Cat.INB_SBM, "sbm");
281 CatSTR.put(Cat.SIS_PTCL, "port_control");
282 CatSTR.put(Cat.SIS_PTED, "port_entry");
283 CatSTR.put(Cat.SIS_IPT, "ipt");
284 CatSTR.put(Cat.SIS_BRTH, "berthing");
285 CatSTR.put(Cat.SIS_DOCK, "dock");
286 CatSTR.put(Cat.SIS_LOCK, "lock");
287 CatSTR.put(Cat.SIS_FBAR, "barrage");
288 CatSTR.put(Cat.SIS_BRDG, "bridge");
289 CatSTR.put(Cat.SIS_DRDG, "dredging");
290 CatSTR.put(Cat.SIS_TRFC, "traffic");
291 CatSTR.put(Cat.SIS_DNGR, "danger");
292 CatSTR.put(Cat.SIS_OBST, "obstruction");
293 CatSTR.put(Cat.SIS_CABL, "cable");
294 CatSTR.put(Cat.SIS_MILY, "military");
295 CatSTR.put(Cat.SIS_DSTR, "distress");
296 CatSTR.put(Cat.SIS_WTHR, "weather");
297 CatSTR.put(Cat.SIS_STRM, "storm");
298 CatSTR.put(Cat.SIS_ICE, "ice");
299 CatSTR.put(Cat.SIS_TIME, "time");
300 CatSTR.put(Cat.SIS_TIDE, "tide");
301 CatSTR.put(Cat.SIS_TSTM, "stream");
302 CatSTR.put(Cat.SIS_TGAG, "gauge");
303 CatSTR.put(Cat.SIS_TSCL, "scale");
304 CatSTR.put(Cat.SIS_DIVE, "diving");
305 CatSTR.put(Cat.SIS_LGAG, "level");
306 CatSTR.put(Cat.LMK_CHMY, "chimney");
307 CatSTR.put(Cat.LMK_CARN, "cairn");
308 CatSTR.put(Cat.LMK_DSHA, "dish_aerial");
309 CatSTR.put(Cat.LMK_FLGS, "flagstaff");
310 CatSTR.put(Cat.LMK_FLRS, "flare_stack");
311 CatSTR.put(Cat.LMK_MNMT, "monument");
312 CatSTR.put(Cat.LMK_TOWR, "tower");
313 CatSTR.put(Cat.LMK_WNDM, "windmotor");
314 CatSTR.put(Cat.LMK_WTRT, "water_tower");
315 CatSTR.put(Cat.LMK_MAST, "mast");
316 CatSTR.put(Cat.LMK_WNDS, "windsock");
317 CatSTR.put(Cat.LMK_CLMN, "column");
318 CatSTR.put(Cat.LMK_OBLK, "obelisk");
319 CatSTR.put(Cat.LMK_STAT, "statue");
320 CatSTR.put(Cat.LMK_CROS, "cross");
321 CatSTR.put(Cat.LMK_DOME, "dome");
322 CatSTR.put(Cat.LMK_SCNR, "radar_scanner");
323 CatSTR.put(Cat.LMK_WNDL, "windmill");
324 CatSTR.put(Cat.LMK_SPIR, "spire");
325 CatSTR.put(Cat.LMK_MNRT, "minaret");
326 CatSTR.put(Cat.OFP_OIL, "oil");
327 CatSTR.put(Cat.OFP_PRD, "production");
328 CatSTR.put(Cat.OFP_OBS, "observation");
329 CatSTR.put(Cat.OFP_ALP, "alp");
330 CatSTR.put(Cat.OFP_SALM, "salm");
331 CatSTR.put(Cat.OFP_MOR, "mooring");
332 CatSTR.put(Cat.OFP_ISL, "island");
333 CatSTR.put(Cat.OFP_FPSO, "fpso");
334 CatSTR.put(Cat.OFP_ACC, "accommodation");
335 CatSTR.put(Cat.OFP_NCCB, "nccb");
336 CatSTR.put(Cat.PIL_VESS, "cruising_vessel");
337 CatSTR.put(Cat.PIL_HELI, "helicopter");
338 CatSTR.put(Cat.PIL_SHORE, "from_shore");
339 CatSTR.put(Cat.RSC_LFB, "lifeboat");
340 CatSTR.put(Cat.RSC_RKT, "rocket");
341 CatSTR.put(Cat.RSC_RSW, "refuge_shipwrecked");
342 CatSTR.put(Cat.RSC_RIT, "refuge_intertidal");
343 CatSTR.put(Cat.RSC_MLB, "lifeboat_moored");
344 CatSTR.put(Cat.RSC_RAD, "radio");
345 CatSTR.put(Cat.RSC_FAE, "firstaid");
346 CatSTR.put(Cat.RSC_SPL, "seaplane");
347 CatSTR.put(Cat.RSC_AIR, "aircraft");
348 CatSTR.put(Cat.RSC_TUG, "tug");
349 CatSTR.put(Cat.RAS_SRV, "surveillance");
350 CatSTR.put(Cat.RAS_CST, "coast");
351 CatSTR.put(Cat.ROS_OMNI, "omnidirectional");
352 CatSTR.put(Cat.ROS_DIRL, "directional");
353 CatSTR.put(Cat.ROS_ROTP, "rotating_pattern");
354 CatSTR.put(Cat.ROS_CNSL, "consol");
355 CatSTR.put(Cat.ROS_RDF, "rdf");
356 CatSTR.put(Cat.ROS_QTG, "qtg");
357 CatSTR.put(Cat.ROS_AERO, "aeronautical");
358 CatSTR.put(Cat.ROS_DECA, "decca");
359 CatSTR.put(Cat.ROS_LORN, "loran");
360 CatSTR.put(Cat.ROS_DGPS, "dgps");
361 CatSTR.put(Cat.ROS_TORN, "toran");
362 CatSTR.put(Cat.ROS_OMGA, "omega");
363 CatSTR.put(Cat.ROS_SYLD, "syledis");
364 CatSTR.put(Cat.ROS_CHKA, "chiaka");
365 CatSTR.put(Cat.ROS_PCOM, "public_communication");
366 CatSTR.put(Cat.ROS_COMB, "commercial_broadcast");
367 CatSTR.put(Cat.ROS_FACS, "facsimile");
368 CatSTR.put(Cat.ROS_TIME, "time_signal");
369 CatSTR.put(Cat.ROS_PAIS, "ais");
370 CatSTR.put(Cat.ROS_SAIS, "s-ais");
371 CatSTR.put(Cat.ROS_VAIS, "v-ais");
372 CatSTR.put(Cat.ROS_VANC, "v-ais_north_cardinal");
373 CatSTR.put(Cat.ROS_VASC, "v-ais_south_cardinal");
374 CatSTR.put(Cat.ROS_VAEC, "v-ais_east_cardinal");
375 CatSTR.put(Cat.ROS_VAWC, "v-ais_west_cardinal");
376 CatSTR.put(Cat.ROS_VAPL, "v-ais_port_lateral");
377 CatSTR.put(Cat.ROS_VASL, "v-ais_starboard_lateral");
378 CatSTR.put(Cat.ROS_VAID, "v-ais_isolated_danger");
379 CatSTR.put(Cat.ROS_VASW, "v-ais_safe_water");
380 CatSTR.put(Cat.ROS_VASP, "v-ais_special_purpose");
381 CatSTR.put(Cat.ROS_VAWK, "v-ais_wreck");
382 CatSTR.put(Cat.NTC_A1, "no_entry");
383 CatSTR.put(Cat.NTC_A1a, "closed_area");
384 CatSTR.put(Cat.NTC_A2, "no_overtaking");
385 CatSTR.put(Cat.NTC_A3, "no_convoy_overtaking");
386 CatSTR.put(Cat.NTC_A4, "no_passing");
387 CatSTR.put(Cat.NTC_A4, "no_convoy_passing");
388 CatSTR.put(Cat.NTC_A5, "no_berthing");
389 CatSTR.put(Cat.NTC_A5_1, "no_berthing_lateral_limit");
390 CatSTR.put(Cat.NTC_A6, "no_anchoring");
391 CatSTR.put(Cat.NTC_A7, "no_mooring");
392 CatSTR.put(Cat.NTC_A8, "no_turning");
393 CatSTR.put(Cat.NTC_A9, "no_wash");
394 CatSTR.put(Cat.NTC_A10a, "no_passage_left");
395 CatSTR.put(Cat.NTC_A10b, "no_passage_right");
396 CatSTR.put(Cat.NTC_A12, "no_motor_craft");
397 CatSTR.put(Cat.NTC_A13, "no_sport_craft");
398 CatSTR.put(Cat.NTC_A14, "no_waterskiing");
399 CatSTR.put(Cat.NTC_A15, "no_sailing_craft");
400 CatSTR.put(Cat.NTC_A16, "no_unpowered_craft");
401 CatSTR.put(Cat.NTC_A17, "no_sailboards");
402 CatSTR.put(Cat.NTC_A18, "no_high_speeds");
403 CatSTR.put(Cat.NTC_A19, "no_launching_beaching");
404 CatSTR.put(Cat.NTC_A20, "no_waterbikes");
405 CatSTR.put(Cat.NTC_B1a, "");
406 CatSTR.put(Cat.NTC_B1b, "");
407 CatSTR.put(Cat.NTC_B2a, "");
408 CatSTR.put(Cat.NTC_B2a, "");
409 CatSTR.put(Cat.NTC_B3a, "");
410 CatSTR.put(Cat.NTC_B3a, "");
411 CatSTR.put(Cat.NTC_B4a, "");
412 CatSTR.put(Cat.NTC_B4a, "");
413 CatSTR.put(Cat.NTC_B5, "");
414 CatSTR.put(Cat.NTC_B6, "");
415 CatSTR.put(Cat.NTC_B7, "");
416 CatSTR.put(Cat.NTC_B8, "");
417 CatSTR.put(Cat.NTC_B9a, "");
418 CatSTR.put(Cat.NTC_B9b, "");
419 CatSTR.put(Cat.NTC_B11, "");
420 CatSTR.put(Cat.NTC_C1, "");
421 CatSTR.put(Cat.NTC_C2, "");
422 CatSTR.put(Cat.NTC_C3, "");
423 CatSTR.put(Cat.NTC_C4, "");
424 CatSTR.put(Cat.NTC_C5a, "");
425 CatSTR.put(Cat.NTC_C5b, "");
426 CatSTR.put(Cat.NTC_D1a, "");
427 CatSTR.put(Cat.NTC_D1b, "");
428 CatSTR.put(Cat.NTC_D2a, "");
429 CatSTR.put(Cat.NTC_D2b, "");
430 CatSTR.put(Cat.NTC_D3a, "");
431 CatSTR.put(Cat.NTC_D3b, "");
432 }
433
434 private Cat category = Cat.NOCAT;
435
436 public Cat getCategory() {
437 return category;
438 }
439
440 public void setCategory(Cat cat) {
441 category = cat;
442 repaint();
443 }
444
445 public enum Shp {
446 UNKSHP, PILLAR, SPAR, CAN, CONI, SPHERI, BARREL, FLOAT, SUPER, BUOYANT,
447 CAIRN, PILE, LATTICE, TOWER, STAKE, POLE, POST, PERCH, BUOY, BEACON
448 }
449
450 public static final EnumMap<Shp, String> ShpSTR = new EnumMap<>(Shp.class);
451 static {
452 ShpSTR.put(Shp.PILLAR, "pillar");
453 ShpSTR.put(Shp.SPAR, "spar");
454 ShpSTR.put(Shp.CAN, "can");
455 ShpSTR.put(Shp.CONI, "conical");
456 ShpSTR.put(Shp.SPHERI, "spherical");
457 ShpSTR.put(Shp.BARREL, "barrel");
458 ShpSTR.put(Shp.FLOAT, "float");
459 ShpSTR.put(Shp.SUPER, "super-buoy");
460 ShpSTR.put(Shp.BUOYANT, "buoyant");
461 ShpSTR.put(Shp.CAIRN, "cairn");
462 ShpSTR.put(Shp.PILE, "pile");
463 ShpSTR.put(Shp.LATTICE, "lattice");
464 ShpSTR.put(Shp.TOWER, "tower");
465 ShpSTR.put(Shp.STAKE, "stake");
466 ShpSTR.put(Shp.PERCH, "perch");
467 }
468
469 private Shp shape = Shp.UNKSHP;
470
471 public Shp getShape() {
472 return shape;
473 }
474
475 public void setShape(Shp shp) {
476 shape = shp;
477 repaint();
478 }
479
480 public enum Col {
481 UNKCOL, BLANK, WHITE, RED, ORANGE, AMBER, YELLOW, GREEN, BLUE, VIOLET, BLACK, GREY, BROWN, MAGENTA, PINK
482 }
483
484 public static final EnumMap<Col, Color> ColMAP = new EnumMap<>(Col.class);
485 static {
486 ColMAP.put(Col.UNKCOL, new Color(0xc0c0c0));
487 ColMAP.put(Col.WHITE, Color.WHITE);
488 ColMAP.put(Col.RED, Color.RED);
489 ColMAP.put(Col.ORANGE, Color.ORANGE);
490 ColMAP.put(Col.AMBER, new Color(0xfbf00f));
491 ColMAP.put(Col.YELLOW, Color.YELLOW);
492 ColMAP.put(Col.GREEN, Color.GREEN);
493 ColMAP.put(Col.BLUE, Color.BLUE);
494 ColMAP.put(Col.VIOLET, new Color(0x8f00ff));
495 ColMAP.put(Col.BLACK, Color.BLACK);
496 ColMAP.put(Col.GREY, Color.GRAY);
497 ColMAP.put(Col.BROWN, new Color(0xa45a58));
498 ColMAP.put(Col.MAGENTA, Color.MAGENTA);
499 ColMAP.put(Col.PINK, Color.PINK);
500 }
501
502 public static final EnumMap<Col, String> ColSTR = new EnumMap<>(Col.class);
503 static {
504 ColSTR.put(Col.WHITE, "white");
505 ColSTR.put(Col.RED, "red");
506 ColSTR.put(Col.ORANGE, "orange");
507 ColSTR.put(Col.AMBER, "amber");
508 ColSTR.put(Col.YELLOW, "yellow");
509 ColSTR.put(Col.GREEN, "green");
510 ColSTR.put(Col.BLUE, "blue");
511 ColSTR.put(Col.VIOLET, "violet");
512 ColSTR.put(Col.BLACK, "black");
513 ColSTR.put(Col.GREY, "grey");
514 ColSTR.put(Col.BROWN, "brown");
515 ColSTR.put(Col.MAGENTA, "magenta");
516 ColSTR.put(Col.PINK, "pink");
517 }
518
519 public Col getColour(Ent ent, int idx) {
520 if (ent == Ent.BODY)
521 return getObjColour(idx);
522 else
523 return getTopColour(idx);
524 }
525
526 public void setColour(Ent ent, Col col) {
527 if (ent == Ent.BODY) {
528 setObjColour(col);
529 } else {
530 setTopColour(col);
531 }
532 }
533
534 public void setColour(Ent ent, int idx, Col col) {
535 if (ent == Ent.BODY) {
536 setObjColour(idx, col);
537 } else {
538 setTopColour(idx, col);
539 }
540 }
541
542 public void addColour(Ent ent, int idx, Col col) {
543 if (ent == Ent.BODY) {
544 addObjColour(idx, col);
545 } else {
546 addTopColour(idx, col);
547 }
548 }
549
550 public void subColour(Ent ent, int idx) {
551 if (ent == Ent.BODY) {
552 subObjColour(idx);
553 } else {
554 subTopColour(idx);
555 }
556 }
557
558 private ArrayList<Col> bodyColour = new ArrayList<>();
559
560 public Col getObjColour(int i) {
561 if (i < bodyColour.size())
562 return bodyColour.get(i);
563 else
564 return Col.UNKCOL;
565 }
566
567 public void setObjColour(Col col) {
568 bodyColour.clear();
569 bodyColour.add(col);
570 repaint();
571 }
572
573 public void setObjColour(int i, Col col) {
574 if (i < bodyColour.size()) {
575 bodyColour.set(i, col);
576 }
577 repaint();
578 }
579
580 public void addObjColour(int i, Col col) {
581 if (bodyColour.size() >= i) {
582 bodyColour.add(i, col);
583 }
584 repaint();
585 }
586
587 public void addObjColour(Col col) {
588 bodyColour.add(col);
589 repaint();
590 }
591
592 public void subObjColour(int i) {
593 if (bodyColour.size() > i) {
594 bodyColour.remove(i);
595 }
596 repaint();
597 }
598
599 private ArrayList<Col> topmarkColour = new ArrayList<>();
600
601 public Col getTopColour(int i) {
602 if (i < topmarkColour.size())
603 return topmarkColour.get(i);
604 else
605 return Col.UNKCOL;
606 }
607
608 public void setTopColour(Col col) {
609 topmarkColour.clear();
610 topmarkColour.add(col);
611 repaint();
612 }
613
614 public void setTopColour(int i, Col col) {
615 if (topmarkColour.size() > i) {
616 topmarkColour.set(i, col);
617 }
618 repaint();
619 }
620
621 public void addTopColour(int i, Col col) {
622 if (topmarkColour.size() >= i) {
623 topmarkColour.add(i, col);
624 }
625 repaint();
626 }
627
628 public void addTopColour(Col col) {
629 topmarkColour.add(col);
630 repaint();
631 }
632
633 public void subTopColour(int i) {
634 if (topmarkColour.size() > i) {
635 topmarkColour.remove(i);
636 }
637 repaint();
638 }
639
640 public enum Chr {
641 UNKCHR, FIXED, FLASH, LFLASH, QUICK, VQUICK, UQUICK, ISOPHASED, OCCULTING, MORSE, ALTERNATING, IQUICK, IVQUICK, IUQUICK
642 }
643
644 public static final Map<EnumSet<Chr>, String> ChrMAP = new HashMap<>();
645 static {
646 ChrMAP.put(EnumSet.of(Chr.FIXED), "F");
647 ChrMAP.put(EnumSet.of(Chr.FLASH), "Fl");
648 ChrMAP.put(EnumSet.of(Chr.LFLASH), "LFl");
649 ChrMAP.put(EnumSet.of(Chr.QUICK), "Q");
650 ChrMAP.put(EnumSet.of(Chr.VQUICK), "VQ");
651 ChrMAP.put(EnumSet.of(Chr.UQUICK), "UQ");
652 ChrMAP.put(EnumSet.of(Chr.ISOPHASED), "Iso");
653 ChrMAP.put(EnumSet.of(Chr.OCCULTING), "Oc");
654 ChrMAP.put(EnumSet.of(Chr.IQUICK), "IQ");
655 ChrMAP.put(EnumSet.of(Chr.IVQUICK), "IVQ");
656 ChrMAP.put(EnumSet.of(Chr.IUQUICK), "IUQ");
657 ChrMAP.put(EnumSet.of(Chr.MORSE), "Mo");
658 ChrMAP.put(EnumSet.of(Chr.FIXED, Chr.FLASH), "FFl");
659 ChrMAP.put(EnumSet.of(Chr.FLASH, Chr.LFLASH), "FlLFl");
660 ChrMAP.put(EnumSet.of(Chr.FIXED, Chr.OCCULTING), "FOc");
661 ChrMAP.put(EnumSet.of(Chr.FIXED, Chr.LFLASH), "FLFl");
662 ChrMAP.put(EnumSet.of(Chr.OCCULTING, Chr.FLASH), "OcFl");
663 ChrMAP.put(EnumSet.of(Chr.QUICK, Chr.LFLASH), "Q+LFl");
664 ChrMAP.put(EnumSet.of(Chr.VQUICK, Chr.LFLASH), "VQ+LFl");
665 ChrMAP.put(EnumSet.of(Chr.UQUICK, Chr.LFLASH), "UQ+LFl");
666 ChrMAP.put(EnumSet.of(Chr.ALTERNATING), "Al");
667 ChrMAP.put(EnumSet.of(Chr.ALTERNATING, Chr.OCCULTING), "Al.Oc");
668 ChrMAP.put(EnumSet.of(Chr.ALTERNATING, Chr.LFLASH), "Al.LFl");
669 ChrMAP.put(EnumSet.of(Chr.ALTERNATING, Chr.FLASH), "Al.Fl");
670 ChrMAP.put(EnumSet.of(Chr.ALTERNATING, Chr.FIXED), "Al.F");
671 ChrMAP.put(EnumSet.of(Chr.ALTERNATING, Chr.FIXED, Chr.FLASH), "Al.FFl");
672 ChrMAP.put(EnumSet.of(Chr.ALTERNATING, Chr.ISOPHASED), "Al.Iso");
673 }
674
675 public enum Vis {
676 UNKVIS, HIGH, LOW, FAINT, INTEN, UNINTEN, REST, OBS, PARTOBS
677 }
678
679 public static final EnumMap<Vis, String> VisSTR = new EnumMap<>(Vis.class);
680 static {
681 VisSTR.put(Vis.HIGH, "high");
682 VisSTR.put(Vis.LOW, "low");
683 VisSTR.put(Vis.FAINT, "faint");
684 VisSTR.put(Vis.INTEN, "intensified");
685 VisSTR.put(Vis.UNINTEN, "unintensified");
686 VisSTR.put(Vis.REST, "restricted");
687 VisSTR.put(Vis.OBS, "obscured");
688 VisSTR.put(Vis.PARTOBS, "part_obscured");
689 }
690
691 public enum Lit {
692 UNKLIT, VERT, HORIZ, DIR, UPPER, LOWER, LEAD, REAR, FRONT, AERO, AIROBS, FOGDET, FLOOD, STRIP, SUBS, SPOT, MOIRE, EMERG, BEAR
693 }
694
695 public static final EnumMap<Lit, String> LitSTR = new EnumMap<>(Lit.class);
696 static {
697 LitSTR.put(Lit.VERT, "vertical");
698 LitSTR.put(Lit.HORIZ, "horizontal");
699 LitSTR.put(Lit.DIR, "directional");
700 LitSTR.put(Lit.UPPER, "upper");
701 LitSTR.put(Lit.LOWER, "lower");
702 LitSTR.put(Lit.LEAD, "leading");
703 LitSTR.put(Lit.REAR, "rear");
704 LitSTR.put(Lit.FRONT, "front");
705 LitSTR.put(Lit.AERO, "aero");
706 LitSTR.put(Lit.AIROBS, "air_obstruction");
707 LitSTR.put(Lit.FOGDET, "fog_detector");
708 LitSTR.put(Lit.FLOOD, "floodlight");
709 LitSTR.put(Lit.STRIP, "striplight");
710 LitSTR.put(Lit.SUBS, "subsidairy");
711 LitSTR.put(Lit.SPOT, "spotlight");
712 LitSTR.put(Lit.MOIRE, "moire");
713 LitSTR.put(Lit.EMERG, "emergency");
714 LitSTR.put(Lit.BEAR, "bearing");
715 }
716
717 public enum Exh {
718 UNKEXH, H24, DAY, NIGHT, FOG, WARN, STORM
719 }
720
721 public static final EnumMap<Exh, String> ExhSTR = new EnumMap<>(Exh.class);
722 static {
723 ExhSTR.put(Exh.H24, "24h");
724 ExhSTR.put(Exh.DAY, "day");
725 ExhSTR.put(Exh.NIGHT, "night");
726 ExhSTR.put(Exh.FOG, "fog");
727 ExhSTR.put(Exh.WARN, "warning");
728 ExhSTR.put(Exh.STORM, "storm");
729 }
730
731 public enum Att {
732 COL, CHR, GRP, SEQ, PER, LIT, BEG, END, RAD, HGT, RNG, VIS, EXH, ORT, MLT, ALT
733 }
734
735 public Object[] sector = {Col.UNKCOL, "", "", "", "", Lit.UNKLIT, "", "",
736 "", "", "", Vis.UNKVIS, Exh.UNKEXH, "", "", Col.UNKCOL };
737
738 private ArrayList<Object[]> sectors = new ArrayList<>();
739
740 public int getSectorCount() {
741 return sectors.size();
742 }
743
744 public boolean isSectored() {
745 return (sectors.size() > 1);
746 }
747
748 public Object getLightAtt(Att att, int i) {
749 return getLightAtt(att.ordinal(), i);
750 }
751
752 public Object getLightAtt(int att, int i) {
753 if (i < sectors.size())
754 return sectors.get(i)[att];
755 else
756 return null;
757 }
758
759 public void setLightAtt(Att att, int i, Object obj) {
760 setLightAtt(att.ordinal(), i, obj);
761 }
762
763 public void setLightAtt(int att, int i, Object obj) {
764 if (sectors.size() == i) {
765 addLight(i);
766 }
767 if (sectors.size() > i) {
768 switch (att) {
769 case 4:
770 case 8:
771 case 9:
772 case 10:
773 sectors.get(i)[att] = validDecimal((String) obj);
774 break;
775 case 6:
776 case 7:
777 case 13:
778 sectors.get(i)[att] = validDecimal((String) obj, 360);
779 break;
780 default:
781 sectors.get(i)[att] = obj;
782 }
783 }
784 repaint();
785 }
786
787 public void addLight(int i) {
788 if (sectors.size() >= i) {
789 if (sectors.size() == 0) {
790 sectors.add(sector.clone());
791 } else {
792 sectors.add(i, sectors.get(0).clone());
793 }
794 }
795 }
796
797 public void nulLight(int i) {
798 if (i == 0) {
799 clrLight();
800 } else {
801 sectors.add(i, sector.clone());
802 }
803 }
804
805 public void addLight() {
806 if (sectors.size() == 0) {
807 sectors.add(sector.clone());
808 } else {
809 sectors.add(sectors.get(0).clone());
810 }
811 }
812
813 public void delLight(int i) {
814 if (sectors.size() > i) {
815 sectors.remove(i);
816 }
817 repaint();
818 }
819
820 public void clrLight() {
821 sectors.clear();
822 addLight();
823 setLightRef("");
824 repaint();
825 }
826
827 public enum Pat {
828 NOPAT, HSTRP, VSTRP, DIAG, SQUARED, BORDER, CROSS, SALTIRE
829 }
830
831 public static final EnumMap<Pat, String> PatSTR = new EnumMap<>(Pat.class);
832 static {
833 PatSTR.put(Pat.HSTRP, "horizontal");
834 PatSTR.put(Pat.VSTRP, "vertical");
835 PatSTR.put(Pat.DIAG, "diagonal");
836 PatSTR.put(Pat.SQUARED, "squared");
837 PatSTR.put(Pat.BORDER, "border");
838 PatSTR.put(Pat.CROSS, "cross");
839 PatSTR.put(Pat.SALTIRE, "saltire");
840 }
841
842 public Pat getPattern(Ent ent) {
843 if (ent == Ent.BODY)
844 return getObjPattern();
845 else
846 return getTopPattern();
847 }
848
849 public void setPattern(Ent ent, Pat pat) {
850 if (ent == Ent.BODY) {
851 setObjPattern(pat);
852 } else {
853 setTopPattern(pat);
854 }
855 }
856
857 private Pat bodyPattern = Pat.NOPAT;
858
859 public Pat getObjPattern() {
860 return bodyPattern;
861 }
862
863 public void setObjPattern(Pat pat) {
864 bodyPattern = pat;
865 }
866
867 private Pat topPattern = Pat.NOPAT;
868
869 public Pat getTopPattern() {
870 return topPattern;
871 }
872
873 public void setTopPattern(Pat pat) {
874 topPattern = pat;
875 }
876
877 public enum Top {
878 NOTOP, CYL, CONE, SPHERE, X_SHAPE, NORTH, SOUTH, EAST, WEST, SPHERES2, BOARD, RHOMBUS, CIRCLE, TRIANGLE, TRIANGLE_INV, SQUARE
879 }
880
881 public static final EnumMap<Top, String> TopSTR = new EnumMap<>(Top.class);
882 static {
883 TopSTR.put(Top.CYL, "cylinder");
884 TopSTR.put(Top.CONE, "cone, point up");
885 TopSTR.put(Top.SPHERE, "sphere");
886 TopSTR.put(Top.X_SHAPE, "x-shape");
887 TopSTR.put(Top.NORTH, "2 cones up");
888 TopSTR.put(Top.SOUTH, "2 cones down");
889 TopSTR.put(Top.EAST, "2 cones base together");
890 TopSTR.put(Top.WEST, "2 cones point together");
891 TopSTR.put(Top.SPHERES2, "2 spheres");
892 TopSTR.put(Top.BOARD, "board");
893 TopSTR.put(Top.RHOMBUS, "rhombus");
894 TopSTR.put(Top.CIRCLE, "circle");
895 TopSTR.put(Top.TRIANGLE, "triangle, point up");
896 TopSTR.put(Top.TRIANGLE_INV, "triangle, point down");
897 TopSTR.put(Top.SQUARE, "square");
898 }
899
900 private Top topShape = Top.NOTOP;
901
902 public Top getTopmark() {
903 return topShape;
904 }
905
906 public void setTopmark(Top top) {
907 topShape = top;
908 repaint();
909 }
910
911 private Cat RoType = Cat.NOROS;
912
913 public Cat getRadio() {
914 return RoType;
915 }
916
917 public void setRadio(Cat type) {
918 RoType = type;
919 repaint();
920 }
921
922 public enum Rtb {
923 NORTB, REFLECTOR, RACON, RAMARK, LEADING
924 }
925
926 public static final EnumMap<Rtb, String> RtbSTR = new EnumMap<>(Rtb.class);
927 static {
928 RtbSTR.put(Rtb.RACON, "racon");
929 RtbSTR.put(Rtb.RAMARK, "ramark");
930 RtbSTR.put(Rtb.LEADING, "leading");
931 }
932
933 private Rtb RaType = Rtb.NORTB;
934
935 public Rtb getRadar() {
936 return RaType;
937 }
938
939 public void setRadar(Rtb type) {
940 RaType = type;
941 if (type == Rtb.NORTB) {
942 setRaconGroup("");
943 setRaconSequence("");
944 setRaconPeriod("");
945 setRaconRange("");
946 setRaconSector1("");
947 setRaconSector2("");
948 }
949 repaint();
950 }
951
952 private String raconGroup = "";
953
954 public String getRaconGroup() {
955 return raconGroup;
956 }
957
958 public void setRaconGroup(String grp) {
959 raconGroup = grp;
960 repaint();
961 }
962
963 private String raconSequence = "";
964
965 public String getRaconSequence() {
966 return raconSequence;
967 }
968
969 public void setRaconSequence(String seq) {
970 raconSequence = seq;
971 repaint();
972 }
973
974 private String raconPeriod = "";
975
976 public String getRaconPeriod() {
977 return raconPeriod;
978 }
979
980 public void setRaconPeriod(String per) {
981 raconPeriod = validDecimal(per);
982 repaint();
983 }
984
985 private String raconRange = "";
986
987 public String getRaconRange() {
988 return raconRange;
989 }
990
991 public void setRaconRange(String rng) {
992 raconRange = validDecimal(rng);
993 repaint();
994 }
995
996 private String raconSector1 = "";
997
998 public String getRaconSector1() {
999 return raconSector1;
1000 }
1001
1002 public void setRaconSector1(String sec) {
1003 raconSector1 = validDecimal(sec);
1004 repaint();
1005 }
1006
1007 private String raconSector2 = "";
1008
1009 public String getRaconSector2() {
1010 return raconSector2;
1011 }
1012
1013 public void setRaconSector2(String sec) {
1014 raconSector2 = validDecimal(sec);
1015 repaint();
1016 }
1017
1018 public enum Fog {
1019 NOFOG, FOGSIG, HORN, SIREN, DIA, BELL, WHIS, GONG, EXPLOS
1020 }
1021
1022 public static final EnumMap<Fog, String> FogSTR = new EnumMap<>(Fog.class);
1023 static {
1024 FogSTR.put(Fog.FOGSIG, "yes");
1025 FogSTR.put(Fog.HORN, "horn");
1026 FogSTR.put(Fog.SIREN, "siren");
1027 FogSTR.put(Fog.DIA, "diaphone");
1028 FogSTR.put(Fog.BELL, "bell");
1029 FogSTR.put(Fog.WHIS, "whistle");
1030 FogSTR.put(Fog.GONG, "gong");
1031 FogSTR.put(Fog.EXPLOS, "explosion");
1032 }
1033
1034 private Fog fogSound = Fog.NOFOG;
1035
1036 public Fog getFogSound() {
1037 return fogSound;
1038 }
1039
1040 public void setFogSound(Fog sound) {
1041 fogSound = sound;
1042 if (sound == Fog.NOFOG) {
1043 setFogGroup("");
1044 setFogSequence("");
1045 setFogPeriod("");
1046 setFogRange("");
1047 }
1048 repaint();
1049 }
1050
1051 private String fogGroup = "";
1052
1053 public String getFogGroup() {
1054 return fogGroup;
1055 }
1056
1057 public void setFogGroup(String grp) {
1058 fogGroup = grp;
1059 repaint();
1060 }
1061
1062 private String fogSequence = "";
1063
1064 public String getFogSequence() {
1065 return fogSequence;
1066 }
1067
1068 public void setFogSequence(String seq) {
1069 fogSequence = seq;
1070 repaint();
1071 }
1072
1073 private String fogRange = "";
1074
1075 public String getFogRange() {
1076 return fogRange;
1077 }
1078
1079 public void setFogRange(String rng) {
1080 fogRange = validDecimal(rng);
1081 repaint();
1082 }
1083
1084 private String fogPeriod = "";
1085
1086 public String getFogPeriod() {
1087 return fogPeriod;
1088 }
1089
1090 public void setFogPeriod(String per) {
1091 fogPeriod = validDecimal(per);
1092 repaint();
1093 }
1094
1095 public enum Sts {
1096 UNKSTS, PERM, OCC, REC, NIU, INT, RESV, TEMP, PRIV, MAND, DEST, EXT, ILLUM, HIST, PUB, SYNC, WATCH, UNWAT, DOUBT
1097 }
1098
1099 public static final EnumMap<Sts, String> StsSTR = new EnumMap<>(Sts.class);
1100 static {
1101 StsSTR.put(Sts.PERM, "permanent");
1102 StsSTR.put(Sts.OCC, "occasional");
1103 StsSTR.put(Sts.REC, "recommended");
1104 StsSTR.put(Sts.NIU, "not_in_use");
1105 StsSTR.put(Sts.INT, "intermittent");
1106 StsSTR.put(Sts.RESV, "reserved");
1107 StsSTR.put(Sts.TEMP, "tempory");
1108 StsSTR.put(Sts.PRIV, "private");
1109 StsSTR.put(Sts.MAND, "mandatory");
1110 StsSTR.put(Sts.DEST, "destroyed");
1111 StsSTR.put(Sts.EXT, "extinguished");
1112 StsSTR.put(Sts.ILLUM, "illuminated");
1113 StsSTR.put(Sts.HIST, "historic");
1114 StsSTR.put(Sts.PUB, "public");
1115 StsSTR.put(Sts.SYNC, "synchronized");
1116 StsSTR.put(Sts.WATCH, "watched");
1117 StsSTR.put(Sts.UNWAT, "unwatched");
1118 StsSTR.put(Sts.DOUBT, "existence_doubtful");
1119 }
1120
1121 private Sts status = Sts.UNKSTS;
1122
1123 public Sts getStatus() {
1124 return status;
1125 }
1126
1127 public void setStatus(Sts sts) {
1128 status = sts;
1129 }
1130
1131 public enum Cns {
1132 UNKCNS, BRICK, CONC, BOULD, HSURF, USURF, WOOD, METAL, GLAS, PAINT
1133 }
1134
1135 public static final EnumMap<Cns, String> CnsSTR = new EnumMap<>(Cns.class);
1136 static {
1137 CnsSTR.put(Cns.BRICK, "masonry");
1138 CnsSTR.put(Cns.CONC, "concreted");
1139 CnsSTR.put(Cns.BOULD, "boulders");
1140 CnsSTR.put(Cns.HSURF, "hard_surfaced");
1141 CnsSTR.put(Cns.USURF, "unsurfaced");
1142 CnsSTR.put(Cns.WOOD, "wooden");
1143 CnsSTR.put(Cns.METAL, "metal");
1144 CnsSTR.put(Cns.GLAS, "grp");
1145 CnsSTR.put(Cns.PAINT, "painted");
1146 }
1147
1148 private Cns construction = Cns.UNKCNS;
1149
1150 public Cns getConstr() {
1151 return construction;
1152 }
1153
1154 public void setConstr(Cns cns) {
1155 construction = cns;
1156 }
1157
1158 public enum Con {
1159 UNKCON, CONSP, NCONS, REFL
1160 }
1161
1162 public static final EnumMap<Con, String> ConSTR = new EnumMap<>(Con.class);
1163 static {
1164 ConSTR.put(Con.CONSP, "conspicuous");
1165 ConSTR.put(Con.NCONS, "not_conspicuous");
1166 ConSTR.put(Con.REFL, "reflector");
1167 }
1168
1169 private Con conspicuity = Con.UNKCON;
1170
1171 public Con getConsp() {
1172 return conspicuity;
1173 }
1174
1175 public void setConsp(Con con) {
1176 conspicuity = con;
1177 }
1178
1179 private Con reflectivity = Con.UNKCON;
1180
1181 public Con getRefl() {
1182 return reflectivity;
1183 }
1184
1185 public void setRefl(Con con) {
1186 reflectivity = con;
1187 }
1188
1189 public enum Fnc {
1190 UNKFNC, HMO, CSTM, HLTH, HOSP, POFF, HOTEL, RWSTA, POLICE, WPOL, PILO, PILL, BANK, DCHQ, TRNS, FACT, PWRS, ADMIN, EDUC, CHCH, CHPL,
1191 TMPL, PGDA, SHSH, BTMP, MOSQ, MRBT, LOOK, COMS, TV, RADO, RADR, LSUP, MWAV, COOL, OBSV, TIMB, CLK, CTRL, AMOR, STAD, BUSS,
1192 PRHB, RGLN, RSTN, RCMD, INFO
1193 }
1194
1195 public static final EnumMap<Fnc, String> FncSTR = new EnumMap<>(Fnc.class);
1196 static {
1197 FncSTR.put(Fnc.UNKFNC, "");
1198 FncSTR.put(Fnc.HMO, "harbour-master");
1199 FncSTR.put(Fnc.CSTM, "customs");
1200 FncSTR.put(Fnc.HLTH, "health");
1201 FncSTR.put(Fnc.HOSP, "hospital");
1202 FncSTR.put(Fnc.POFF, "post_office");
1203 FncSTR.put(Fnc.HOTEL, "hotel");
1204 FncSTR.put(Fnc.RWSTA, "railway_station");
1205 FncSTR.put(Fnc.POLICE, "police_station");
1206 FncSTR.put(Fnc.WPOL, "water-police_station");
1207 FncSTR.put(Fnc.PILO, "pilot_office");
1208 FncSTR.put(Fnc.PILL, "pilot_lookout");
1209 FncSTR.put(Fnc.BANK, "bank");
1210 FncSTR.put(Fnc.DCHQ, "district_control");
1211 FncSTR.put(Fnc.TRNS, "transit_shed");
1212 FncSTR.put(Fnc.FACT, "factory");
1213 FncSTR.put(Fnc.PWRS, "power_station");
1214 FncSTR.put(Fnc.ADMIN, "administrative");
1215 FncSTR.put(Fnc.EDUC, "educational");
1216 FncSTR.put(Fnc.CHCH, "church");
1217 FncSTR.put(Fnc.CHPL, "chapel");
1218 FncSTR.put(Fnc.TMPL, "temple");
1219 FncSTR.put(Fnc.PGDA, "pagoda");
1220 FncSTR.put(Fnc.SHSH, "shinto_shrine");
1221 FncSTR.put(Fnc.BTMP, "buddhist_temple");
1222 FncSTR.put(Fnc.MOSQ, "mosque");
1223 FncSTR.put(Fnc.MRBT, "marabout");
1224 FncSTR.put(Fnc.LOOK, "lookout");
1225 FncSTR.put(Fnc.COMS, "communication");
1226 FncSTR.put(Fnc.TV, "television");
1227 FncSTR.put(Fnc.RADO, "radio");
1228 FncSTR.put(Fnc.RADR, "radar");
1229 FncSTR.put(Fnc.LSUP, "light_support");
1230 FncSTR.put(Fnc.MWAV, "microwave");
1231 FncSTR.put(Fnc.COOL, "cooling");
1232 FncSTR.put(Fnc.OBSV, "observation");
1233 FncSTR.put(Fnc.TIMB, "time_ball");
1234 FncSTR.put(Fnc.CLK, "clock");
1235 FncSTR.put(Fnc.CTRL, "control");
1236 FncSTR.put(Fnc.AMOR, "airship_mooring");
1237 FncSTR.put(Fnc.STAD, "stadium");
1238 FncSTR.put(Fnc.BUSS, "bus_station");
1239 FncSTR.put(Fnc.PRHB, "prohibition");
1240 FncSTR.put(Fnc.RGLN, "regulation");
1241 FncSTR.put(Fnc.RSTN, "restriction");
1242 FncSTR.put(Fnc.RCMD, "recommendation");
1243 FncSTR.put(Fnc.INFO, "information");
1244 }
1245
1246 private Fnc function = Fnc.UNKFNC;
1247
1248 public Fnc getFunc() {
1249 return function;
1250 }
1251
1252 public void setFunc(Fnc fnc) {
1253 function = fnc;
1254 repaint();
1255 }
1256
1257 public String information = "";
1258
1259 public String getInfo() {
1260 return information;
1261 }
1262
1263 public void setInfo(String str) {
1264 information = str.trim();
1265 }
1266
1267 public String source = "";
1268
1269 public String getSource() {
1270 return source;
1271 }
1272
1273 public void setSource(String str) {
1274 source = str.trim();
1275 }
1276
1277 public String elevation = "";
1278
1279 public String getElevation() {
1280 return elevation;
1281 }
1282
1283 public void setElevation(String str) {
1284 elevation = validDecimal(str);
1285 }
1286
1287 public String height = "";
1288
1289 public String getObjectHeight() {
1290 return height;
1291 }
1292
1293 public void setObjectHeight(String str) {
1294 height = validDecimal(str);
1295 }
1296
1297 private String channel = "";
1298
1299 public String getChannel() {
1300 return channel;
1301 }
1302
1303 public void setChannel(String per) {
1304 channel = validDecimal(per);
1305 repaint();
1306 }
1307
1308 public String ref = "";
1309
1310 public String getRef() {
1311 return ref;
1312 }
1313
1314 public void setRef(String str) {
1315 ref = str;
1316 }
1317
1318 public String lightRef = "";
1319
1320 public String getLightRef() {
1321 return lightRef;
1322 }
1323
1324 public void setLightRef(String str) {
1325 lightRef = str;
1326 }
1327
1328 public String fixme = "";
1329
1330 public String getFixme() {
1331 return fixme;
1332 }
1333
1334 public void setFixme(String str) {
1335 fixme = str;
1336 }
1337
1338 public boolean testValid() {
1339 if (dlg.node == null) return false;
1340 boolean tmp = false;
1341 PanelMain.messageBar.setText("");
1342 switch (getObject()) {
1343 case BCNCAR:
1344 case BCNLAT:
1345 case BOYCAR:
1346 case BOYLAT:
1347 if ((getCategory() != Cat.NOCAT) && (getShape() != Shp.UNKSHP)) {
1348 tmp = true;
1349 }
1350 break;
1351 case BCNISD:
1352 case BCNSAW:
1353 case BCNSPP:
1354 case BOYISD:
1355 case BOYSAW:
1356 case BOYSPP:
1357 if (getShape() != Shp.UNKSHP) {
1358 tmp = true;
1359 }
1360 break;
1361 case FLTCAR:
1362 case FLTISD:
1363 case FLTLAT:
1364 case FLTSAW:
1365 case FLTSPP:
1366 if (getObjColour(0) != Col.UNKCOL) {
1367 tmp = true;
1368 }
1369 break;
1370 case LITMAJ:
1371 case LITMIN:
1372 case LITFLT:
1373 case LITVES:
1374 case LITHSE:
1375 case SISTAW:
1376 case SISTAT:
1377 case OFSPLF:
1378 case MORFAC:
1379 case BOYINB:
1380 case PILBOP:
1381 case RSCSTA:
1382 case RDOSTA:
1383 case RADSTA:
1384 tmp = true;
1385 break;
1386 case NOTMRK:
1387 if (getCategory() != Cat.NOCAT) {
1388 tmp = true;
1389 }
1390 break;
1391 case LNDMRK:
1392 if ((getCategory() != Cat.NOCAT) || (getFunc() != Fnc.UNKFNC)) {
1393 tmp = true;
1394 }
1395 break;
1396 default:
1397 break;
1398 }
1399 if (tmp) {
1400 SmedAction.panelMain.moreButton.setVisible(true);
1401 SmedAction.panelMain.saveButton.setEnabled(true);
1402 SmedAction.panelMain.topButton.setEnabled(true);
1403 SmedAction.panelMain.fogButton.setEnabled(true);
1404 SmedAction.panelMain.radButton.setEnabled(true);
1405 SmedAction.panelMain.litButton.setEnabled(true);
1406 return true;
1407 } else {
1408 SmedAction.panelMain.moreButton.setVisible(false);
1409 SmedAction.panelMain.moreButton.setText(">>");
1410 SmedAction.panelMain.topButton.setEnabled(false);
1411 SmedAction.panelMain.fogButton.setEnabled(false);
1412 SmedAction.panelMain.radButton.setEnabled(false);
1413 SmedAction.panelMain.litButton.setEnabled(false);
1414 PanelMain.messageBar.setText("Seamark not recognised");
1415 return false;
1416 }
1417 }
1418
1419 public void clrMark() {
1420 setName("");
1421 setObject(Obj.UNKOBJ);
1422 clrLight();
1423 setFogSound(Fog.NOFOG);
1424 setRadar(Rtb.NORTB);
1425 setRadio(Cat.NOROS);
1426 setStatus(Sts.UNKSTS);
1427 setConstr(Cns.UNKCNS);
1428 setConsp(Con.UNKCON);
1429 setRefl(Con.UNKCON);
1430 setRef("");
1431 setObjectHeight("");
1432 setElevation("");
1433 setChannel("");
1434 setInfo("");
1435 setSource("");
1436 setFixme("");
1437 SmedAction.panelMain.syncPanel();
1438 repaint();
1439 }
1440
1441 public String validDecimal(String str) {
1442 str = str.trim().replace(',', '.');
1443 if (!(str.isEmpty()) && !(str.matches("^[+-]??\\d+(\\.\\d+)??$"))) {
1444 PanelMain.messageBar.setText(Messages.getString("NotDecimal"));
1445 return "";
1446 } else {
1447 PanelMain.messageBar.setText("");
1448 return str;
1449 }
1450 }
1451
1452 public String validDecimal(String str, float max) {
1453 str = validDecimal(str);
1454 if (!(str.isEmpty()) && (Float.valueOf(str) > max)) {
1455 PanelMain.messageBar.setText(Messages.getString("TooBig") + " (" + max + ")");
1456 return "";
1457 } else {
1458 PanelMain.messageBar.setText("");
1459 return str;
1460 }
1461 }
1462
1463 public void parseMark(OsmPrimitive node) {
1464 PanelMain.messageBar.setText("");
1465 String str = Main.pref.get("smedplugin.IALA");
1466 if (str.equals("C")) {
1467 setRegion(Reg.C);
1468 } else if (str.equals("B")) {
1469 setRegion(Reg.B);
1470 } else {
1471 setRegion(Reg.A);
1472 }
1473
1474 Map<String, String> keys = node.getKeys();
1475
1476 str = "";
1477 if (keys.containsKey("seamark:type")) {
1478 str = keys.get("seamark:type");
1479 }
1480
1481 clrMark();
1482 for (Obj obj : ObjSTR.keySet()) {
1483 if (ObjSTR.get(obj).equals(str)) {
1484 setObject(obj);
1485 }
1486 }
1487
1488 if (str.equals("")) {
1489 PanelMain.messageBar.setText("No seamark");
1490 }
1491 if (getObject() == Obj.UNKOBJ) {
1492 PanelMain.messageBar.setText("Seamark not recognised");
1493 }
1494
1495 setName("");
1496 for (Obj obj : ObjSTR.keySet()) {
1497 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":name")) {
1498 str = keys.get("seamark:" + ObjSTR.get(obj) + ":name");
1499 setName(str);
1500 }
1501 }
1502 if (keys.containsKey("seamark:name")) {
1503 str = keys.get("seamark:name");
1504 setName(str);
1505 }
1506
1507 for (Obj obj : ObjSTR.keySet()) {
1508 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":category")) {
1509 str = keys.get("seamark:" + ObjSTR.get(obj) + ":category");
1510 if (obj == getObject()) {
1511 setCategory(Cat.NOCAT);
1512 for (Cat cat : CatSTR.keySet()) {
1513 if (CatSTR.get(cat).equals(str)) {
1514 setCategory(cat);
1515 }
1516 }
1517 }
1518 }
1519 }
1520
1521 for (Obj obj : ObjSTR.keySet()) {
1522 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":shape")) {
1523 str = keys.get("seamark:" + ObjSTR.get(obj) + ":shape");
1524 setShape(Shp.UNKSHP);
1525 for (Shp shp : ShpSTR.keySet()) {
1526 if (ShpSTR.get(shp).equals(str)) {
1527 setShape(shp);
1528 }
1529 }
1530 }
1531 }
1532 if (getShape() == Shp.UNKSHP) {
1533 if (EntMAP.get(getObject()) == Ent.BUOY) {
1534 setShape(Shp.BUOY);
1535 }
1536 if (EntMAP.get(getObject()) == Ent.BEACON) {
1537 setShape(Shp.BEACON);
1538 }
1539 if (EntMAP.get(getObject()) == Ent.LFLOAT)
1540 if (getObject() == Obj.LITVES) {
1541 setShape(Shp.SUPER);
1542 } else {
1543 setShape(Shp.FLOAT);
1544 }
1545 }
1546
1547 for (Obj obj : ObjSTR.keySet()) {
1548 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":colour")) {
1549 str = keys.get("seamark:" + ObjSTR.get(obj) + ":colour");
1550 bodyColour.clear();
1551 for (String item : str.split(";")) {
1552 for (Col col : ColSTR.keySet()) {
1553 if (ColSTR.get(col).equals(item)) {
1554 bodyColour.add(col);
1555 }
1556 }
1557 }
1558 }
1559 }
1560
1561 for (Obj obj : ObjSTR.keySet()) {
1562 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":colour_pattern")) {
1563 str = keys.get("seamark:" + ObjSTR.get(obj) + ":colour_pattern");
1564 setObjPattern(Pat.NOPAT);
1565 for (Pat pat : PatSTR.keySet()) {
1566 if (PatSTR.get(pat).equals(str)) {
1567 setObjPattern(pat);
1568 }
1569 }
1570 }
1571
1572 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":height")) {
1573 setObjectHeight(keys.get("seamark:" + ObjSTR.get(obj) + ":height"));
1574 }
1575 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":elevation")) {
1576 setElevation(keys.get("seamark:" + ObjSTR.get(obj) + ":elevation"));
1577 }
1578 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":channel")) {
1579 setChannel(keys.get("seamark:" + ObjSTR.get(obj) + ":channel"));
1580 }
1581 }
1582
1583 for (Obj obj : ObjSTR.keySet()) {
1584 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":function")) {
1585 str = keys.get("seamark:" + ObjSTR.get(obj) + ":function");
1586 setFunc(Fnc.UNKFNC);
1587 for (Fnc fnc : FncSTR.keySet()) {
1588 if (FncSTR.get(fnc).equals(str)) {
1589 setFunc(fnc);
1590 }
1591 }
1592 }
1593 }
1594
1595 if ((getObject() == Obj.LNDMRK) && (getCategory() == Cat.NOCAT) && (getFunc() == Fnc.UNKFNC)) {
1596 setObject(Obj.LITHSE);
1597 }
1598
1599 if (getObject() == Obj.LITFLT) {
1600 switch (getObjColour(0)) {
1601 case RED:
1602 if ((getObjColour(1) == Col.WHITE) && (getObjColour(2) == Col.UNKCOL)) {
1603 setObject(Obj.FLTSAW);
1604 setCategory(Cat.NOCAT);
1605 } else if (getObjColour(1) == Col.UNKCOL) {
1606 setObject(Obj.FLTLAT);
1607 if (getRegion() == Reg.B) {
1608 setCategory(Cat.LAM_STBD);
1609 } else {
1610 setCategory(Cat.LAM_PORT);
1611 }
1612 } else if ((getObjColour(1) == Col.GREEN)
1613 && (getObjColour(2) == Col.RED)) {
1614 setObject(Obj.FLTLAT);
1615 if (getRegion() == Reg.B) {
1616 setCategory(Cat.LAM_PSTBD);
1617 } else {
1618 setCategory(Cat.LAM_PPORT);
1619 }
1620 } else if ((getObjColour(1) == Col.WHITE)
1621 && (getObjColour(2) == Col.RED)) {
1622 setObject(Obj.FLTLAT);
1623 setCategory(Cat.LAM_PORT);
1624 } else {
1625 setObject(Obj.FLTSPP);
1626 setCategory(Cat.NOCAT);
1627 }
1628 break;
1629 case GREEN:
1630 if (getObjColour(1) == Col.UNKCOL) {
1631 setObject(Obj.FLTLAT);
1632 if (getRegion() == Reg.B) {
1633 setCategory(Cat.LAM_PORT);
1634 } else {
1635 setCategory(Cat.LAM_STBD);
1636 }
1637 } else if ((getObjColour(1) == Col.RED)
1638 && (getObjColour(2) == Col.GREEN)) {
1639 setObject(Obj.FLTLAT);
1640 if (getRegion() == Reg.B) {
1641 setCategory(Cat.LAM_PPORT);
1642 } else {
1643 setCategory(Cat.LAM_PSTBD);
1644 }
1645 } else if ((getObjColour(1) == Col.WHITE)
1646 && (getObjColour(2) == Col.GREEN)) {
1647 setObject(Obj.FLTLAT);
1648 setCategory(Cat.LAM_STBD);
1649 } else {
1650 setObject(Obj.FLTSPP);
1651 setCategory(Cat.NOCAT);
1652 }
1653 break;
1654 case YELLOW:
1655 if (getObjColour(1) == Col.BLACK) {
1656 setObject(Obj.FLTCAR);
1657 if (getObjColour(2) == Col.YELLOW) {
1658 setCategory(Cat.CAM_WEST);
1659 } else {
1660 setCategory(Cat.CAM_SOUTH);
1661 }
1662 } else {
1663 setObject(Obj.FLTSPP);
1664 setCategory(Cat.NOCAT);
1665 }
1666 break;
1667 case BLACK:
1668 if (getObjColour(1) == Col.RED) {
1669 setObject(Obj.FLTISD);
1670 setCategory(Cat.NOCAT);
1671 } else if (getObjColour(1) == Col.YELLOW) {
1672 setObject(Obj.FLTCAR);
1673 if (getObjColour(2) == Col.BLACK) {
1674 setCategory(Cat.CAM_EAST);
1675 } else {
1676 setCategory(Cat.CAM_NORTH);
1677 }
1678 } else {
1679 setObject(Obj.FLTSPP);
1680 setCategory(Cat.NOCAT);
1681 }
1682 break;
1683 default:
1684 setCategory(Cat.NOCAT);
1685 }
1686 }
1687
1688 for (Obj obj : ObjSTR.keySet()) {
1689 if (keys.containsKey("seamark:" + ObjSTR.get(obj) + ":system")) {
1690 str = keys.get("seamark:" + ObjSTR.get(obj) + ":system");
1691 if (str.equals("iala-a")) {
1692 setRegion(Reg.A);
1693 } else if (str.equals("iala-b")) {
1694 setRegion(Reg.B);
1695 } else {
1696 setRegion(Reg.C);
1697 }
1698 } else if (GrpMAP.get(object) == Grp.LAT) {
1699 switch (getCategory()) {
1700 case LAM_PORT:
1701 if (getObjColour(0) == Col.RED) {
1702 if (getObjColour(1) == Col.WHITE) {
1703 setRegion(Reg.C);
1704 } else {
1705 setRegion(Reg.A);
1706 }
1707 }
1708 if (getObjColour(0) == Col.GREEN) {
1709 setRegion(Reg.B);
1710 }
1711 break;
1712 case LAM_PPORT:
1713 if (getObjColour(0) == Col.RED) {
1714 if (getObjColour(3) == Col.GREEN) {
1715 setRegion(Reg.C);
1716 } else {
1717 setRegion(Reg.B);
1718 }
1719 }
1720 if (getObjColour(0) == Col.GREEN) {
1721 setRegion(Reg.A);
1722 }
1723 break;
1724 case LAM_STBD:
1725 if (getObjColour(0) == Col.GREEN) {
1726 if (getObjColour(1) == Col.WHITE) {
1727 setRegion(Reg.C);
1728 } else {
1729 setRegion(Reg.A);
1730 }
1731 }
1732 if (getObjColour(0) == Col.RED) {
1733 setRegion(Reg.B);
1734 }
1735 break;
1736 case LAM_PSTBD:
1737 if (getObjColour(0) == Col.GREEN) {
1738 setRegion(Reg.B);
1739 }
1740 if (getObjColour(0) == Col.RED) {
1741 if (getObjColour(3) == Col.GREEN) {
1742 setRegion(Reg.C);
1743 } else {
1744 setRegion(Reg.A);
1745 }
1746 }
1747 break;
1748 default:
1749 break;
1750 }
1751 }
1752 }
1753
1754 if (keys.containsKey("seamark:topmark:shape")) {
1755 str = keys.get("seamark:topmark:shape");
1756 setTopmark(Top.NOTOP);
1757 for (Top top : TopSTR.keySet()) {
1758 if (TopSTR.get(top).equals(str)) {
1759 setTopmark(top);
1760 }
1761 }
1762 }
1763 if (keys.containsKey("seamark:topmark:colour")) {
1764 str = keys.get("seamark:topmark:colour");
1765 setTopColour(Col.UNKCOL);
1766 for (Col col : ColSTR.keySet()) {
1767 if (ColSTR.get(col).equals(str)) {
1768 setTopColour(col);
1769 }
1770 }
1771 }
1772 if (keys.containsKey("seamark:topmark:colour_pattern")) {
1773 str = keys.get("seamark:topmark:colour_pattern");
1774 setTopPattern(Pat.NOPAT);
1775 for (Pat pat : PatSTR.keySet()) {
1776 if (PatSTR.get(pat).equals(str)) {
1777 setTopPattern(pat);
1778 }
1779 }
1780 }
1781
1782 clrLight();
1783 for (int i = 0; i < 30; i++) {
1784 String secStr = (i == 0) ? "" : (":" + Integer.toString(i));
1785 if (keys.containsKey("seamark:light" + secStr + ":colour")) {
1786 nulLight(i);
1787 str = keys.get("seamark:light" + secStr + ":colour");
1788 if (str.contains(";")) {
1789 String[] strs = str.split(";");
1790 for (Col col : ColSTR.keySet()) {
1791 if ((strs.length > 1) && ColSTR.get(col).equals(strs[1])) {
1792 setLightAtt(Att.ALT, i, col);
1793 }
1794 }
1795 str = strs[0];
1796 }
1797 for (Col col : ColSTR.keySet()) {
1798 if (ColSTR.get(col).equals(str)) {
1799 setLightAtt(Att.COL, i, col);
1800 }
1801 }
1802 }
1803 if (keys.containsKey("seamark:light" + secStr + ":character")) {
1804 str = keys.get("seamark:light" + secStr + ":character");
1805 if (str.contains("(") && str.contains(")")) {
1806 int i1 = str.indexOf("(");
1807 int i2 = str.indexOf(")");
1808 setLightAtt(Att.GRP, i, str.substring((i1+1), i2));
1809 str = str.substring(0, i1) + str.substring((i2+1), str.length());
1810 }
1811 setLightAtt(Att.CHR, i, str);
1812 }
1813 if (keys.containsKey("seamark:light" + secStr + ":group")) {
1814 setLightAtt(Att.GRP, i, keys.get("seamark:light" + secStr + ":group"));
1815 }
1816 if (keys.containsKey("seamark:light" + secStr + ":sequence")) {
1817 setLightAtt(Att.SEQ, i, keys.get("seamark:light" + secStr + ":sequence"));
1818 }
1819 if (keys.containsKey("seamark:light" + secStr + ":period")) {
1820 setLightAtt(Att.PER, i, keys.get("seamark:light" + secStr + ":period"));
1821 }
1822 if (keys.containsKey("seamark:light" + secStr + ":category")) {
1823 str = keys.get("seamark:light" + secStr + ":category");
1824 if (str.equals("vert")) {
1825 str = "vertical";
1826 }
1827 if (str.equals("horiz")) {
1828 str = "horizontal";
1829 }
1830 for (Lit lit : LitSTR.keySet()) {
1831 if (LitSTR.get(lit).equals(str)) {
1832 setLightAtt(Att.LIT, i, lit);
1833 }
1834 }
1835 }
1836 if (keys.containsKey("seamark:light" + secStr + ":sector_start")) {
1837 setLightAtt(Att.BEG, i, keys.get("seamark:light" + secStr + ":sector_start"));
1838 }
1839 if (keys.containsKey("seamark:light" + secStr + ":sector_end")) {
1840 setLightAtt(Att.END, i, keys.get("seamark:light" + secStr + ":sector_end"));
1841 }
1842 if (keys.containsKey("seamark:light" + secStr + ":radius")) {
1843 setLightAtt(Att.RAD, i, keys.get("seamark:light" + secStr + ":radius"));
1844 }
1845 if (keys.containsKey("seamark:light" + secStr + ":height")) {
1846 setLightAtt(Att.HGT, i, keys.get("seamark:light" + secStr + ":height"));
1847 }
1848 if (keys.containsKey("seamark:light" + secStr + ":range")) {
1849 setLightAtt(Att.RNG, i, keys.get("seamark:light" + secStr + ":range"));
1850 }
1851 if (keys.containsKey("seamark:light" + secStr + ":visibility")) {
1852 str = keys.get("seamark:light" + secStr + ":visibility");
1853 for (Vis vis : VisSTR.keySet()) {
1854 if (VisSTR.get(vis).equals(str)) {
1855 setLightAtt(Att.VIS, i, vis);
1856 }
1857 }
1858 }
1859 if (keys.containsKey("seamark:light" + secStr + ":exhibition")) {
1860 str = keys.get("seamark:light" + secStr + ":exhibition");
1861 for (Exh exh : ExhSTR.keySet()) {
1862 if (ExhSTR.get(exh).equals(str)) {
1863 setLightAtt(Att.EXH, i, exh);
1864 }
1865 }
1866 }
1867 if (keys.containsKey("seamark:light" + secStr + ":orientation")) {
1868 setLightAtt(Att.ORT, i, keys.get("seamark:light" + secStr + ":orientation"));
1869 }
1870 if (keys.containsKey("seamark:light" + secStr + ":multiple")) {
1871 setLightAtt(Att.MLT, i, keys.get("seamark:light" + secStr + ":multiple"));
1872 }
1873
1874 if (sectors.size() == i) {
1875 break;
1876 }
1877 }
1878
1879 if (keys.containsKey("seamark:fog_signal")) {
1880 setFogSound(Fog.FOGSIG);
1881 }
1882 if (keys.containsKey("seamark:fog_signal:category")) {
1883 str = keys.get("seamark:fog_signal:category");
1884 setFogSound(Fog.NOFOG);
1885 for (Fog fog : FogSTR.keySet()) {
1886 if (FogSTR.get(fog).equals(str)) {
1887 setFogSound(fog);
1888 }
1889 }
1890 }
1891 if (keys.containsKey("seamark:fog_signal:group")) {
1892 setFogGroup(keys.get("seamark:fog_signal:group"));
1893 }
1894 if (keys.containsKey("seamark:fog_signal:period")) {
1895 setFogPeriod(keys.get("seamark:fog_signal:period"));
1896 }
1897 if (keys.containsKey("seamark:fog_signal:sequence")) {
1898 setFogSequence(keys.get("seamark:fog_signal:sequence"));
1899 }
1900 if (keys.containsKey("seamark:fog_signal:range")) {
1901 setFogRange(keys.get("seamark:fog_signal:range"));
1902 }
1903
1904 if (keys.containsKey("seamark:radio_station:category")) {
1905 str = keys.get("seamark:radio_station:category");
1906 setRadio(Cat.NOROS);
1907 for (Cat rdo : CatSTR.keySet()) {
1908 if (CatSTR.get(rdo).equals(str)) {
1909 setRadio(rdo);
1910 }
1911 }
1912 }
1913
1914 if (keys.containsKey("seamark:radar_reflector")) {
1915 setRadar(Rtb.REFLECTOR);
1916 }
1917 if (keys.containsKey("seamark:radar_transponder:category")) {
1918 str = keys.get("seamark:radar_transponder:category");
1919 setRadar(Rtb.NORTB);
1920 for (Rtb rtb : RtbSTR.keySet()) {
1921 if (RtbSTR.get(rtb).equals(str)) {
1922 setRadar(rtb);
1923 }
1924 }
1925 }
1926 if (keys.containsKey("seamark:radar_transponder:group")) {
1927 setRaconGroup(keys.get("seamark:radar_transponder:group"));
1928 }
1929 if (keys.containsKey("seamark:radar_transponder:period")) {
1930 setRaconPeriod(keys.get("seamark:radar_transponder:period"));
1931 }
1932 if (keys.containsKey("seamark:radar_transponder:sequence")) {
1933 setRaconSequence(keys.get("seamark:radar_transponder:sequence"));
1934 }
1935 if (keys.containsKey("seamark:radar_transponder:range")) {
1936 setRaconRange(keys.get("seamark:radar_transponder:range"));
1937 }
1938 if (keys.containsKey("seamark:radar_transponder:sector_start")) {
1939 setRaconSector1(keys.get("seamark:radar_transponder:sector_start"));
1940 }
1941 if (keys.containsKey("seamark:radar_transponder:sector_end")) {
1942 setRaconSector2(keys.get("seamark:radar_transponder:sector_end"));
1943 }
1944
1945 if (keys.containsKey("seamark:information")) {
1946 setInfo(keys.get("seamark:information"));
1947 }
1948 if (keys.containsKey("seamark:light:information")) {
1949 setInfo(getInfo() + keys.get("seamark:light:information"));
1950 }
1951 if (keys.containsKey("seamark:" + ObjSTR.get(getObject()) + "information")) {
1952 setInfo(getInfo() + keys.get("seamark:" + ObjSTR.get(getObject()) + "information"));
1953 }
1954 if (keys.containsKey("seamark:source")) {
1955 setSource(keys.get("seamark:source"));
1956 }
1957 if (keys.containsKey("seamark:light:source")) {
1958 setSource(getSource() + keys.get("seamark:light:source"));
1959 }
1960 if (keys.containsKey("seamark:" + ObjSTR.get(getObject()) + "source")) {
1961 setSource(getSource() + keys.get("seamark:" + ObjSTR.get(getObject()) + "source"));
1962 }
1963 if (keys.containsKey("seamark:height")) {
1964 setObjectHeight(keys.get("seamark:height"));
1965 }
1966 if (keys.containsKey("seamark:elevation")) {
1967 setElevation(keys.get("seamark:elevation"));
1968 }
1969 if (keys.containsKey("seamark:status")) {
1970 str = keys.get("seamark:status");
1971 setStatus(Sts.UNKSTS);
1972 for (Sts sts : StsSTR.keySet()) {
1973 if (StsSTR.get(sts).equals(str)) {
1974 setStatus(sts);
1975 }
1976 }
1977 }
1978 if (keys.containsKey("seamark:construction")) {
1979 str = keys.get("seamark:construction");
1980 setConstr(Cns.UNKCNS);
1981 for (Cns cns : CnsSTR.keySet()) {
1982 if (CnsSTR.get(cns).equals(str)) {
1983 setConstr(cns);
1984 }
1985 }
1986 }
1987 if (keys.containsKey("seamark:conspicuity")) {
1988 str = keys.get("seamark:conspicuity");
1989 setConsp(Con.UNKCON);
1990 for (Con con : ConSTR.keySet()) {
1991 if (ConSTR.get(con).equals(str)) {
1992 setConsp(con);
1993 }
1994 }
1995 }
1996 if (keys.containsKey("seamark:reflectivity")) {
1997 str = keys.get("seamark:reflectivity");
1998 setRefl(Con.UNKCON);
1999 for (Con con : ConSTR.keySet()) {
2000 if (ConSTR.get(con).equals(str)) {
2001 setRefl(con);
2002 }
2003 }
2004 }
2005
2006 if (keys.containsKey("seamark:ref")) {
2007 setRef(keys.get("seamark:ref"));
2008 }
2009 if (keys.containsKey("seamark:reference")) {
2010 setRef(keys.get("seamark:reference"));
2011 }
2012 if (keys.containsKey("seamark:light:ref")) {
2013 setLightRef(keys.get("seamark:light:ref"));
2014 }
2015 if (keys.containsKey("seamark:light:reference")) {
2016 setLightRef(keys.get("seamark:light:reference"));
2017 }
2018 if (keys.containsKey("seamark:fixme")) {
2019 setFixme(keys.get("seamark:fixme"));
2020 }
2021
2022 dlg.panelMain.syncPanel();
2023 }
2024
2025 @Override
2026 public void paintComponent(Graphics g) {
2027 super.paintComponent(g);
2028
2029 if (dlg.node == null) return;
2030
2031 Graphics2D g2 = (Graphics2D) g;
2032
2033 String colStr;
2034 String lblStr;
2035 String imgStr = "/images/";
2036 if (getShape() != Shp.UNKSHP) {
2037 switch (getShape()) {
2038 case TOWER:
2039 imgStr += "Tower";
2040 break;
2041 case BUOY:
2042 case PILLAR:
2043 imgStr += "Pillar";
2044 break;
2045 case SPAR:
2046 imgStr += "Spar";
2047 break;
2048 case CAN:
2049 imgStr += "Can";
2050 break;
2051 case CONI:
2052 imgStr += "Cone";
2053 break;
2054 case SPHERI:
2055 imgStr += "Sphere";
2056 break;
2057 case BARREL:
2058 imgStr += "Barrel";
2059 break;
2060 case CAIRN:
2061 imgStr += "Cairn";
2062 break;
2063 case FLOAT:
2064 imgStr += "Float";
2065 break;
2066 case BEACON:
2067 case PILE:
2068 case LATTICE:
2069 case BUOYANT:
2070 imgStr += "Beacon";
2071 break;
2072 case SUPER:
2073 imgStr += "Super";
2074 break;
2075 case STAKE:
2076 case POLE:
2077 case POST:
2078 imgStr += "Stake";
2079 break;
2080 case PERCH:
2081 if (getCategory() == Cat.LAM_PORT) {
2082 imgStr += "Perch_Port";
2083 } else {
2084 imgStr += "Perch_Starboard";
2085 }
2086 break;
2087 default:
2088 break;
2089 }
2090 colStr = imgStr;
2091 lblStr = "";
2092 for (Col col : bodyColour) {
2093 switch (col) {
2094 case WHITE:
2095 colStr += "_White";
2096 lblStr += "W";
2097 break;
2098 case RED:
2099 colStr += "_Red";
2100 lblStr += "R";
2101 break;
2102 case ORANGE:
2103 colStr += "_Orange";
2104 lblStr += "Or";
2105 break;
2106 case AMBER:
2107 colStr += "_Amber";
2108 lblStr += "Am";
2109 break;
2110 case YELLOW:
2111 colStr += "_Yellow";
2112 lblStr += "Y";
2113 break;
2114 case GREEN:
2115 colStr += "_Green";
2116 lblStr += "G";
2117 break;
2118 case BLUE:
2119 colStr += "_Blue";
2120 lblStr += "Bu";
2121 break;
2122 case VIOLET:
2123 colStr += "_Violet";
2124 lblStr += "Vi";
2125 break;
2126 case BLACK:
2127 colStr += "_Black";
2128 lblStr += "B";
2129 break;
2130 case GREY:
2131 colStr += "_Grey";
2132 lblStr += "Gr";
2133 break;
2134 case BROWN:
2135 colStr += "_Brown";
2136 lblStr += "Br";
2137 break;
2138 case MAGENTA:
2139 colStr += "_Magenta";
2140 lblStr += "Mg";
2141 break;
2142 case PINK:
2143 colStr += "_Pink";
2144 lblStr += "Pk";
2145 break;
2146 default:
2147 break;
2148 }
2149 }
2150 if (!imgStr.equals("/images/")) {
2151 colStr += ".png";
2152 if (getClass().getResource(colStr) == null) {
2153 System.out.println("Missing image1: " + colStr);
2154 imgStr += ".png";
2155 if (getClass().getResource(imgStr) == null) {
2156 System.out.println("Missing image2: " + imgStr);
2157 } else {
2158 g2.drawImage(new ImageIcon(getClass().getResource(imgStr)).getImage(), 7, -15, null);
2159 g2.drawString(lblStr, 75, 110);
2160 }
2161 } else {
2162 g2.drawImage(new ImageIcon(getClass().getResource(colStr)).getImage(), 7, -15, null);
2163 }
2164 }
2165 } else if (getObject() != Obj.UNKOBJ) {
2166 switch (getObject()) {
2167 case LNDMRK:
2168 switch (getCategory()) {
2169 case LMK_CHMY:
2170 imgStr += "Chimney";
2171 break;
2172 case LMK_CARN:
2173 imgStr += "Cairn";
2174 break;
2175 case LMK_DSHA:
2176 imgStr += "DishAerial";
2177 break;
2178 case LMK_FLGS:
2179 imgStr += "Flagstaff";
2180 break;
2181 case LMK_FLRS:
2182 imgStr += "FlareStack";
2183 break;
2184 case LMK_MNMT:
2185 case LMK_CLMN:
2186 case LMK_OBLK:
2187 case LMK_STAT:
2188 imgStr += "Monument";
2189 break;
2190 case LMK_MAST:
2191 imgStr += "RadioMast";
2192 break;
2193 case LMK_TOWR:
2194 if ((getFunc() == Fnc.CHCH) || (getFunc() == Fnc.CHPL)) {
2195 imgStr += "ChurchTower";
2196 } else {
2197 imgStr += "LandTower";
2198 }
2199 break;
2200 case LMK_WNDM:
2201 imgStr += "Wind_Motor";
2202 break;
2203 case LMK_WTRT:
2204 imgStr += "WaterTower";
2205 break;
2206 case LMK_DOME:
2207 if ((getFunc() == Fnc.CHCH) || (getFunc() == Fnc.CHPL)) {
2208 imgStr += "ChurchDome";
2209 } else {
2210 imgStr += "Dome";
2211 }
2212 break;
2213 case LMK_SPIR:
2214 if ((getFunc() == Fnc.CHCH) || (getFunc() == Fnc.CHPL)) {
2215 imgStr += "ChurchSpire";
2216 } else {
2217 imgStr += "Spire";
2218 }
2219 break;
2220 case LMK_MNRT:
2221 imgStr += "Minaret";
2222 break;
2223 case LMK_WNDS:
2224 imgStr += "Windsock";
2225 break;
2226 case LMK_CROS:
2227 imgStr += "Cross";
2228 break;
2229 case LMK_SCNR:
2230 imgStr += "Signal_Station";
2231 break;
2232 case LMK_WNDL:
2233 imgStr += "Windmill";
2234 break;
2235 case NOCAT:
2236 switch (getFunc()) {
2237 case CHCH:
2238 case CHPL:
2239 imgStr += "Church";
2240 break;
2241 case TMPL:
2242 case PGDA:
2243 case SHSH:
2244 case BTMP:
2245 imgStr += "Temple";
2246 break;
2247 case MOSQ:
2248 imgStr += "Minaret";
2249 break;
2250 case MRBT:
2251 imgStr += "Spire";
2252 break;
2253 default:
2254 break;
2255 }
2256 break;
2257 default:
2258 break;
2259 }
2260 break;
2261 case LITHSE:
2262 imgStr += "Light_House";
2263 break;
2264 case LITMAJ:
2265 imgStr += "Light_Major";
2266 break;
2267 case LITMIN:
2268 imgStr += "Light_Minor";
2269 break;
2270 case LITFLT:
2271 imgStr += "Float";
2272 break;
2273 case LITVES:
2274 imgStr += "Super";
2275 break;
2276 case SISTAW:
2277 imgStr += "Signal_Station";
2278 break;
2279 case SISTAT:
2280 imgStr += "Signal_Station";
2281 break;
2282 case OFSPLF:
2283 if (getCategory() == Cat.OFP_FPSO) {
2284 imgStr += "Storage";
2285 } else {
2286 imgStr += "Platform";
2287 }
2288 break;
2289 case MORFAC:
2290 switch (getCategory()) {
2291 case MOR_DLPN:
2292 imgStr += "Dolphin";
2293 break;
2294 case MOR_DDPN:
2295 imgStr += "DeviationDolphin";
2296 break;
2297 case MOR_POST:
2298 imgStr += "Post";
2299 break;
2300 case MOR_BUOY:
2301 imgStr += "Sphere";
2302 break;
2303 default:
2304 break;
2305 }
2306 break;
2307 case BOYINB:
2308 imgStr += "Super";
2309 break;
2310 case CGUSTA:
2311 imgStr += "Signal_Station";
2312 break;
2313 case PILBOP:
2314 imgStr += "Pilot";
2315 break;
2316 case RSCSTA:
2317 imgStr += "Rescue";
2318 break;
2319 case RDOSTA:
2320 case RADSTA:
2321 imgStr += "Signal_Station";
2322 g2.drawImage(new ImageIcon(getClass().getResource("/images/Radar_Station.png")).getImage(), 7, -15, null);
2323 break;
2324 default:
2325 break;
2326 }
2327 if (!imgStr.equals("/images/")) {
2328 imgStr += ".png";
2329 if (getClass().getResource(imgStr) == null) {
2330 System.out.println("Missing image3: " + imgStr);
2331 } else {
2332 g2.drawImage(new ImageIcon(getClass().getResource(imgStr)).getImage(), 7, -15, null);
2333 }
2334 }
2335 }
2336
2337 if (getTopmark() != Top.NOTOP) {
2338 imgStr = "/images/Top_";
2339 switch (getTopmark()) {
2340 case CYL:
2341 imgStr += "Can";
2342 break;
2343 case CONE:
2344 imgStr += "Cone";
2345 break;
2346 case SPHERE:
2347 imgStr += "Sphere";
2348 break;
2349 case X_SHAPE:
2350 imgStr += "X";
2351 break;
2352 case NORTH:
2353 imgStr += "North";
2354 break;
2355 case SOUTH:
2356 imgStr += "South";
2357 break;
2358 case EAST:
2359 imgStr += "East";
2360 break;
2361 case WEST:
2362 imgStr += "West";
2363 break;
2364 case SPHERES2:
2365 imgStr += "Isol";
2366 break;
2367 default:
2368 break;
2369 }
2370 colStr = imgStr;
2371 for (Col col : topmarkColour) {
2372 switch (col) {
2373 case WHITE:
2374 colStr += "_White";
2375 break;
2376 case RED:
2377 colStr += "_Red";
2378 break;
2379 case ORANGE:
2380 colStr += "_Orange";
2381 break;
2382 case AMBER:
2383 colStr += "_Amber";
2384 break;
2385 case YELLOW:
2386 colStr += "_Yellow";
2387 break;
2388 case GREEN:
2389 colStr += "_Green";
2390 break;
2391 case BLUE:
2392 colStr += "_Blue";
2393 break;
2394 case VIOLET:
2395 colStr += "_Violet";
2396 break;
2397 case BLACK:
2398 colStr += "_Black";
2399 break;
2400 default:
2401 break;
2402 }
2403 }
2404 switch (getShape()) {
2405 case CAN:
2406 case CONI:
2407 case SPHERI:
2408 case BARREL:
2409 imgStr += "_Buoy_Small";
2410 colStr += "_Buoy_Small";
2411 break;
2412 case PILLAR:
2413 case SPAR:
2414 imgStr += "_Buoy";
2415 colStr += "_Buoy";
2416 break;
2417 case FLOAT:
2418 case SUPER:
2419 imgStr += "_Float";
2420 colStr += "_Float";
2421 break;
2422 case BUOYANT:
2423 case CAIRN:
2424 case PILE:
2425 case LATTICE:
2426 case TOWER:
2427 case STAKE:
2428 case POLE:
2429 case POST:
2430 case BEACON:
2431 imgStr += "_Beacon";
2432 colStr += "_Beacon";
2433 break;
2434 default:
2435 break;
2436 }
2437 colStr += ".png";
2438 if (getClass().getResource(colStr) == null) {
2439 System.out.println("Missing image4: " + colStr);
2440 imgStr += ".png";
2441 if (getClass().getResource(imgStr) == null) {
2442 System.out.println("Missing image5: " + imgStr);
2443 return;
2444 } else {
2445 g2.drawImage(new ImageIcon(getClass().getResource(imgStr)).getImage(), 7, -15, null);
2446 }
2447 } else {
2448 g2.drawImage(new ImageIcon(getClass().getResource(colStr)).getImage(), 7, -15, null);
2449 }
2450 } else {
2451 if ((getObject() == Obj.BOYINB) || ((getObject() == Obj.MORFAC) && (getCategory() == Cat.MOR_BUOY))) {
2452 imgStr = "/images/Top_Mooring";
2453 switch (getShape()) {
2454 case CAN:
2455 case CONI:
2456 case SPHERI:
2457 case BARREL:
2458 imgStr += "_Buoy_Small";
2459 break;
2460 case FLOAT:
2461 case SUPER:
2462 imgStr += "_Float";
2463 break;
2464 default:
2465 if (getObject() == Obj.MORFAC) {
2466 imgStr += "_Buoy_Small";
2467 } else {
2468 imgStr += "_Float";
2469 }
2470 break;
2471 }
2472 imgStr += ".png";
2473 if (getClass().getResource(imgStr) == null) {
2474 System.out.println("Missing image6: " + imgStr);
2475 return;
2476 } else {
2477 g2.drawImage(new ImageIcon(getClass().getResource(imgStr)).getImage(), 7, -15, null);
2478 }
2479 }
2480 }
2481
2482 for (int i = 1; i < sectors.size(); i++) {
2483 g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
2484 g2.setStroke(new BasicStroke(6.0f));
2485 if (!((String) getLightAtt(Att.BEG, i)).isEmpty() && !((String) getLightAtt(Att.END, i)).isEmpty()) {
2486 if (getLightAtt(Att.COL, i) != Col.UNKCOL) {
2487 g2.setPaint(ColMAP.get(getLightAtt(Att.COL, i)));
2488 Double a0 = 270 - Double.parseDouble((String) getLightAtt(Att.BEG, i));
2489 Double da = 270 - Double.parseDouble((String) getLightAtt(Att.END, i)) - a0;
2490 da -= da > 0 ? 360 : 0;
2491 g2.draw(new Arc2D.Double(12, 15, 140, 140, a0, da, Arc2D.OPEN));
2492 }
2493 if (getLightAtt(Att.ALT, i) != Col.UNKCOL) {
2494 g2.setPaint(ColMAP.get(getLightAtt(Att.ALT, i)));
2495 Double a0 = 270 - Double.parseDouble((String) getLightAtt(Att.BEG, i));
2496 Double da = 270 - Double.parseDouble((String) getLightAtt(Att.END, i)) - a0;
2497 da -= da > 0 ? 360 : 0;
2498 g2.draw(new Arc2D.Double(17, 20, 130, 130, a0, da, Arc2D.OPEN));
2499 }
2500 } else if ((getLightAtt(Att.LIT, i) == Lit.DIR) && !((String) getLightAtt(Att.ORT, i)).isEmpty()) {
2501 if (getLightAtt(Att.COL, i) != Col.UNKCOL) {
2502 g2.setPaint(ColMAP.get(getLightAtt(Att.COL, i)));
2503 Double a0 = 270 - Double.parseDouble((String) getLightAtt(Att.ORT, i)) + 2.0;
2504 Double da = -4.0;
2505 g2.draw(new Arc2D.Double(12, 15, 140, 140, a0, da, Arc2D.OPEN));
2506 }
2507 if (getLightAtt(Att.ALT, i) != Col.UNKCOL) {
2508 g2.setPaint(ColMAP.get(getLightAtt(Att.ALT, i)));
2509 Double a0 = 270 - Double.parseDouble((String) getLightAtt(Att.ORT, i)) + 2.0;
2510 Double da = -4.0;
2511 g2.draw(new Arc2D.Double(17, 20, 130, 130, a0, da, Arc2D.OPEN));
2512 }
2513 }
2514 }
2515 g2.setPaint(Color.BLACK);
2516 if ((getLightAtt(Att.COL, 0) != Col.UNKCOL) || !(((String) getLightAtt(Att.CHR, 0)).isEmpty())) {
2517 if (sectors.size() == 1) {
2518 if (((String) getLightAtt(Att.CHR, 0)).contains("Al")) {
2519 g2.drawImage(new ImageIcon(getClass().getResource("/images/Light_Magenta_120.png")).getImage(), 7, -15, null);
2520 } else {
2521 switch ((Col) getLightAtt(Att.COL, 0)) {
2522 case RED:
2523 g2.drawImage(new ImageIcon(getClass().getResource("/images/Light_Red_120.png")).getImage(), 7, -15, null);
2524 break;
2525 case GREEN:
2526 g2.drawImage(new ImageIcon(getClass().getResource("/images/Light_Green_120.png")).getImage(), 7, -15, null);
2527 break;
2528 case WHITE:
2529 case YELLOW:
2530 g2.drawImage(new ImageIcon(getClass().getResource("/images/Light_White_120.png")).getImage(), 7, -15, null);
2531 break;
2532 default:
2533 g2.drawImage(new ImageIcon(getClass().getResource("/images/Light_Magenta_120.png")).getImage(), 7, -15, null);
2534 }
2535 }
2536 }
2537 String c = (String) getLightAtt(Att.CHR, 0);
2538 String tmp = "";
2539 if (c.contains("+")) {
2540 int i1 = c.indexOf("+");
2541 tmp = c.substring(i1, c.length());
2542 c = c.substring(0, i1);
2543 if (!((String) getLightAtt(Att.GRP, 0)).isEmpty()) {
2544 c += "(" + (String) getLightAtt(Att.GRP, 0) + ")";
2545 }
2546 if (tmp != null) {
2547 c += tmp;
2548 }
2549 } else if (!((String) getLightAtt(Att.GRP, 0)).isEmpty()) {
2550 c += "(" + (String) getLightAtt(Att.GRP, 0) + ")";
2551 }
2552 switch ((Col) getLightAtt(Att.COL, 0)) {
2553 case WHITE:
2554 c += ".W";
2555 break;
2556 case YELLOW:
2557 c += ".Y";
2558 break;
2559 case RED:
2560 c += ".R";
2561 break;
2562 case GREEN:
2563 c += ".G";
2564 break;
2565 case AMBER:
2566 c += ".Am";
2567 break;
2568 case ORANGE:
2569 c += ".Or";
2570 break;
2571 case BLUE:
2572 c += ".Bu";
2573 break;
2574 case VIOLET:
2575 c += ".Vi";
2576 break;
2577 default:
2578 break;
2579 }
2580 switch ((Col) getLightAtt(Att.ALT, 0)) {
2581 case WHITE:
2582 c += "W";
2583 break;
2584 case YELLOW:
2585 c += "Y";
2586 break;
2587 case RED:
2588 c += "R";
2589 break;
2590 case GREEN:
2591 c += "G";
2592 break;
2593 case AMBER:
2594 c += "Am";
2595 break;
2596 case ORANGE:
2597 c += "Or";
2598 break;
2599 case BLUE:
2600 c += "Bu";
2601 break;
2602 case VIOLET:
2603 c += "Vi";
2604 break;
2605 default:
2606 break;
2607 }
2608 tmp = (String) getLightAtt(Att.MLT, 0);
2609 if (!tmp.isEmpty()) {
2610 c = tmp + c;
2611 }
2612 if (getLightAtt(Att.LIT, 0) != Lit.UNKLIT) {
2613 switch ((Lit) getLightAtt(Att.LIT, 0)) {
2614 case VERT:
2615 c += "(Vert)";
2616 break;
2617 case HORIZ:
2618 c += "(Horiz)";
2619 break;
2620 default:
2621 break;
2622 }
2623 }
2624 tmp = (String) getLightAtt(Att.PER, 0);
2625 if (!tmp.isEmpty()) {
2626 c += " " + tmp + "s";
2627 }
2628 g2.drawString(c, 100, 70);
2629 }
2630
2631 if (getFogSound() != Fog.NOFOG) {
2632 g2.drawImage(new ImageIcon(getClass().getResource("/images/Fog_Signal.png")).getImage(), 7, -15, null);
2633 String str = "";
2634 if (getFogSound() != Fog.FOGSIG) {
2635 switch (getFogSound()) {
2636 case HORN:
2637 str = "Horn";
2638 break;
2639 case SIREN:
2640 str = "Siren";
2641 break;
2642 case DIA:
2643 str = "Dia";
2644 break;
2645 case BELL:
2646 str = "Bell";
2647 break;
2648 case WHIS:
2649 str = "Whis";
2650 break;
2651 case GONG:
2652 str = "Gong";
2653 break;
2654 case EXPLOS:
2655 str = "Explos";
2656 break;
2657 default:
2658 break;
2659 }
2660 }
2661 if (!getFogGroup().isEmpty()) {
2662 str += ("(" + getFogGroup() + ")");
2663 } else {
2664 str += " ";
2665 }
2666 if (!getFogPeriod().isEmpty()) {
2667 str += getFogPeriod() + "s";
2668 }
2669 g2.drawString(str, 0, 70);
2670 }
2671
2672 if (RaType != Rtb.NORTB) {
2673 if (getRadar() == Rtb.REFLECTOR) {
2674 g2.drawImage(new ImageIcon(getClass().getResource("/images/Radar_Reflector_355.png")).getImage(), 7, -15, null);
2675 } else {
2676 g2.drawImage(new ImageIcon(getClass().getResource("/images/Radar_Station.png")).getImage(), 7, -15, null);
2677 String str = "";
2678 if (getRadar() == Rtb.RAMARK) {
2679 str += "Ramark";
2680 } else {
2681 str += "Racon";
2682 }
2683 if (!getRaconGroup().isEmpty()) {
2684 str += ("(" + getRaconGroup() + ")");
2685 } else {
2686 str += " ";
2687 }
2688 if (!getRaconPeriod().isEmpty()) {
2689 str += getRaconPeriod() + "s";
2690 }
2691 g2.drawString(str, 0, 50);
2692 }
2693 }
2694
2695 if (RoType != Cat.NOROS) {
2696 g2.drawImage(new ImageIcon(getClass().getResource("/images/Radar_Station.png")).getImage(), 7, -15, null);
2697 g2.drawString("AIS", 0, 30);
2698 }
2699 }
2700
2701 public void saveSign(OsmPrimitive node) {
2702
2703 if (getObject() != Obj.UNKOBJ) {
2704
2705 Main.pref.put("smedplugin.IALA", getRegion() == Reg.C ? "C" : (getRegion() == Reg.B ? "B" : "A"));
2706
2707 for (String str : node.getKeys().keySet()) {
2708 if (str.trim().matches("^seamark:\\S+")) {
2709 Main.main.undoRedo.add(new ChangePropertyCommand(node, str, null));
2710 }
2711 }
2712
2713 if (!getName().isEmpty()) {
2714 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:name", getName()));
2715 }
2716
2717 String objStr = ObjSTR.get(object);
2718 if (objStr != null) {
2719 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:type", objStr));
2720
2721 if (getShape() != Shp.FLOAT) {
2722 String str = CatSTR.get(getCategory());
2723 if (str != null) {
2724 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":category", str));
2725 }
2726 if ((getShape() != Shp.BUOY) && (getShape() != Shp.BEACON)) {
2727 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":shape", ShpSTR.get(getShape())));
2728 }
2729 }
2730
2731 if ((getObjColour(0) != Col.UNKCOL) && getShape() != Shp.PERCH) {
2732 String str = ColSTR.get(getObjColour(0));
2733 for (int i = 1; bodyColour.size() > i; i++) {
2734 str += (";" + ColSTR.get(getObjColour(i)));
2735 }
2736 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":colour", str));
2737 }
2738
2739 if (getObjPattern() != Pat.NOPAT) {
2740 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":colour_pattern",
2741 PatSTR.get(getObjPattern())));
2742 }
2743
2744 if (getFunc() != Fnc.UNKFNC) {
2745 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":function", FncSTR.get(getFunc())));
2746 }
2747
2748 if ((GrpMAP.get(object) == Grp.LAT) && (getShape() != Shp.PERCH)
2749 || (getObject() == Obj.FLTLAT)) {
2750 switch (region) {
2751 case A:
2752 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":system", "iala-a"));
2753 break;
2754 case B:
2755 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":system", "iala-b"));
2756 break;
2757 case C:
2758 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":system", "other"));
2759 break;
2760 default:
2761 break;
2762 }
2763 }
2764 if (!getObjectHeight().isEmpty()) {
2765 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":height", getObjectHeight()));
2766 }
2767 if (!getElevation().isEmpty()) {
2768 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":elevation", getElevation()));
2769 }
2770 if (!getChannel().isEmpty()) {
2771 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:" + objStr + ":channel", getChannel()));
2772 }
2773 }
2774 if (getTopmark() != Top.NOTOP) {
2775 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:topmark:shape", TopSTR.get(getTopmark())));
2776 if (getTopPattern() != Pat.NOPAT) {
2777 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:topmark:colour_pattern", PatSTR.get(getTopPattern())));
2778 }
2779 if (getTopColour(0) != Col.UNKCOL) {
2780 String str = ColSTR.get(getTopColour(0));
2781 for (int i = 1; topmarkColour.size() > i; i++) {
2782 str += (";" + ColSTR.get(getTopColour(i)));
2783 }
2784 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:topmark:colour", str));
2785 }
2786 }
2787
2788 for (int i = (sectors.size() > 1 ? 1 : 0); i < sectors.size(); i++) {
2789 String secStr = (i == 0) ? "" : (":" + Integer.toString(i));
2790 if (sectors.get(i)[0] != Col.UNKCOL)
2791 if ((sectors.get(i)[15] != Col.UNKCOL) && ((String) sectors.get(i)[1]).contains("Al")) {
2792 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":colour",
2793 (ColSTR.get(sectors.get(i)[0])) + ";" + ColSTR.get(sectors.get(i)[15])));
2794 } else {
2795 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":colour",
2796 ColSTR.get(sectors.get(i)[0])));
2797 }
2798 if (!((String) sectors.get(i)[1]).isEmpty()) {
2799 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":character", (String) sectors.get(i)[1]));
2800 } else if (!((String) sectors.get(0)[1]).isEmpty()) {
2801 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":character", (String) sectors.get(0)[1]));
2802 }
2803 if (!((String) sectors.get(i)[2]).isEmpty()) {
2804 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":group", (String) sectors.get(i)[2]));
2805 } else if (!((String) sectors.get(0)[2]).isEmpty()) {
2806 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":group", (String) sectors.get(0)[2]));
2807 }
2808 if (!((String) sectors.get(i)[3]).isEmpty()) {
2809 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":sequence", (String) sectors.get(i)[3]));
2810 } else if (!((String) sectors.get(0)[3]).isEmpty()) {
2811 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":sequence", (String) sectors.get(0)[3]));
2812 }
2813 if (!((String) sectors.get(i)[4]).isEmpty()) {
2814 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":period", (String) sectors.get(i)[4]));
2815 } else if (!((String) sectors.get(0)[4]).isEmpty()) {
2816 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":period", (String) sectors.get(0)[4]));
2817 }
2818 if (sectors.get(i)[5] != Lit.UNKLIT) {
2819 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":category",
2820 LitSTR.get(sectors.get(i)[5])));
2821 } else if (sectors.get(0)[5] != Lit.UNKLIT) {
2822 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":category",
2823 LitSTR.get(sectors.get(0)[5])));
2824 }
2825 if (!((String) sectors.get(i)[6]).isEmpty()) {
2826 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":sector_start",
2827 (String) sectors.get(i)[6]));
2828 }
2829 if (!((String) sectors.get(i)[7]).isEmpty()) {
2830 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":sector_end",
2831 (String) sectors.get(i)[7]));
2832 }
2833 if (!((String) sectors.get(i)[8]).isEmpty()) {
2834 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":radius", (String) sectors.get(i)[8]));
2835 } else if (!((String) sectors.get(0)[8]).isEmpty()) {
2836 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":radius", (String) sectors.get(0)[8]));
2837 }
2838 if (!((String) sectors.get(i)[9]).isEmpty()) {
2839 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":height", (String) sectors.get(i)[9]));
2840 } else if (!((String) sectors.get(0)[9]).isEmpty()) {
2841 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":height", (String) sectors.get(0)[9]));
2842 }
2843 if (!((String) sectors.get(i)[10]).isEmpty()) {
2844 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":range", (String) sectors.get(i)[10]));
2845 } else if (!((String) sectors.get(0)[10]).isEmpty()) {
2846 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":range", (String) sectors.get(0)[10]));
2847 }
2848 if (sectors.get(i)[11] != Vis.UNKVIS) {
2849 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":visibility",
2850 VisSTR.get(sectors.get(i)[11])));
2851 } else if (sectors.get(0)[11] != Vis.UNKVIS) {
2852 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":visibility",
2853 VisSTR.get(sectors.get(0)[11])));
2854 }
2855 if (sectors.get(i)[12] != Exh.UNKEXH) {
2856 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":exhibition",
2857 ExhSTR.get(sectors.get(i)[12])));
2858 } else if (sectors.get(0)[12] != Exh.UNKEXH) {
2859 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":exhibition",
2860 ExhSTR.get(sectors.get(0)[12])));
2861 }
2862 if (!((String) sectors.get(i)[13]).isEmpty()) {
2863 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":orientation",
2864 (String) sectors.get(i)[13]));
2865 }
2866 if (!((String) sectors.get(i)[14]).isEmpty()) {
2867 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":multiple", (String) sectors.get(i)[14]));
2868 } else if (!((String) sectors.get(0)[14]).isEmpty()) {
2869 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light" + secStr + ":multiple", (String) sectors.get(0)[14]));
2870 }
2871 }
2872
2873 if (getFogSound() != Fog.NOFOG) {
2874 if (getFogSound() == Fog.FOGSIG) {
2875 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:fog_signal", "yes"));
2876 } else {
2877 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:fog_signal:category", FogSTR.get(getFogSound())));
2878 }
2879 if (!getFogGroup().isEmpty()) {
2880 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:fog_signal:group", getFogGroup()));
2881 }
2882 if (!getFogPeriod().isEmpty()) {
2883 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:fog_signal:period", getFogPeriod()));
2884 }
2885 if (!getFogSequence().isEmpty()) {
2886 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:fog_signal:sequence", getFogSequence()));
2887 }
2888 if (!getFogRange().isEmpty()) {
2889 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:fog_signal:range", getFogRange()));
2890 }
2891 }
2892
2893 if (RoType != Cat.NOROS) {
2894 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radio_station:category", CatSTR.get(getRadio())));
2895 }
2896
2897 if (RaType != Rtb.NORTB) {
2898 if (getRadar() == Rtb.REFLECTOR) {
2899 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radar_reflector", "yes"));
2900 } else {
2901 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radar_transponder:category", RtbSTR.get(getRadar())));
2902 if (!getRaconGroup().isEmpty()) {
2903 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radar_transponder:group", getRaconGroup()));
2904 }
2905 if (!getRaconPeriod().isEmpty()) {
2906 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radar_transponder:period", getRaconPeriod()));
2907 }
2908 if (!getRaconSequence().isEmpty()) {
2909 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radar_transponder:sequence", getRaconSequence()));
2910 }
2911 if (!getRaconRange().isEmpty()) {
2912 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radar_transponder:range", getRaconRange()));
2913 }
2914 if ((!getRaconSector1().isEmpty()) && (!getRaconSector2().isEmpty())) {
2915 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radar_transponder:sector_start", getRaconSector1()));
2916 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:radar_transponder:sector_end", getRaconSector2()));
2917 }
2918 }
2919 }
2920
2921 if (!getInfo().isEmpty()) {
2922 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:information", getInfo()));
2923 }
2924 if (!getSource().isEmpty()) {
2925 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:source", getSource()));
2926 }
2927 if (getStatus() != Sts.UNKSTS) {
2928 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:status", StsSTR.get(getStatus())));
2929 }
2930 if (getConstr() != Cns.UNKCNS) {
2931 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:construction", CnsSTR.get(getConstr())));
2932 }
2933 if (getConsp() != Con.UNKCON) {
2934 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:conspicuity", ConSTR.get(getConsp())));
2935 }
2936 if (getRefl() != Con.UNKCON) {
2937 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:reflectivity", ConSTR.get(getRefl())));
2938 }
2939 if (!getRef().isEmpty()) {
2940 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:reference", getRef()));
2941 }
2942 if (!getLightRef().isEmpty()) {
2943 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:light:reference", getLightRef()));
2944 }
2945 if (!getFixme().isEmpty()) {
2946 Main.main.undoRedo.add(new ChangePropertyCommand(node, "seamark:fixme", getFixme()));
2947 }
2948 }
2949 }
2950
2951}
Note: See TracBrowser for help on using the repository browser.