source: osm/applications/editors/josm/plugins/smed/plugs/oseam/src/oseam/seamarks/SeaMark.java@ 28157

Last change on this file since 28157 was 28157, checked in by malcolmh, 12 years ago

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