Ignore:
Timestamp:
2010-08-21T20:25:09+02:00 (14 years ago)
Author:
malcolmh
Message:

error tolerant parsing

File:
1 edited

Legend:

Unmodified
Added
Removed
  • applications/editors/josm/plugins/toms/src/toms/seamarks/buoys/BuoyLat.java

    r22692 r22722  
    1616
    1717public class BuoyLat extends Buoy {
    18         public BuoyLat(SmpDialogAction dia, int type) {
     18        public BuoyLat(SmpDialogAction dia, Node node) {
    1919                super(dia);
     20
     21                String str;
     22                Map<String, String> keys;
     23                keys = node.getKeys();
     24                setNode(node);
    2025
    2126                dlg.cbM01Kennung.removeAllItems();
     
    3237                dlg.cbM01Kennung.setSelectedIndex(0);
    3338
    34                 setBuoyIndex(type);
    3539                setStyleIndex(0);
    3640                setLightColour();
     
    4347                dlg.tbM01Region.setEnabled(true);
    4448
     49                if (keys.containsKey("name"))
     50                        setName(keys.get("name"));
     51
     52                if (keys.containsKey("seamark:name"))
     53                        setName(keys.get("seamark:name"));
     54
     55                if (keys.containsKey("seamark:buoy_lateral:name"))
     56                        setName(keys.get("seamark:buoy_lateral:name"));
     57                else if (keys.containsKey("seamark:beacon_lateral:name"))
     58                        setName(keys.get("seamark:beacon_lateral:name"));
     59                else if (keys.containsKey("seamark:light_float:name"))
     60                        setName(keys.get("seamark:light_float:name"));
     61
     62                String cat = "";
     63                String col = "";
     64
     65                if (keys.containsKey("seamark:buoy_lateral:category"))
     66                        cat = keys.get("seamark:buoy_lateral:category");
     67                else if (keys.containsKey("seamark:beacon_lateral:category"))
     68                        cat = keys.get("seamark:beacon_lateral:category");
     69
     70                if (keys.containsKey("seamark:buoy_lateral:colour"))
     71                        col = keys.get("seamark:buoy_lateral:colour");
     72                else if (keys.containsKey("seamark:beacon_lateral:colour"))
     73                        col = keys.get("seamark:beacon_lateral:colour");
     74                else if (keys.containsKey("seamark:light_float:colour"))
     75                        col = keys.get("seamark:light_float:colour");
     76
     77                if (cat.equals("")) {
     78                        if (col.equals("red")) {
     79                                setColour(RED);
     80                                if (getRegion() == IALA_A)
     81                                        setBuoyIndex(PORT_HAND);
     82                                else
     83                                        setBuoyIndex(STARBOARD_HAND);
     84                        } else if (col.equals("green")) {
     85                                setColour(GREEN);
     86                                if (getRegion() == IALA_A)
     87                                        setBuoyIndex(STARBOARD_HAND);
     88                                else
     89                                        setBuoyIndex(PORT_HAND);
     90                        } else if (col.equals("red;green;red")) {
     91                                setColour(RED_GREEN_RED);
     92                                if (getRegion() == IALA_A)
     93                                        setBuoyIndex(PREF_PORT_HAND);
     94                                else
     95                                        setBuoyIndex(PREF_STARBOARD_HAND);
     96                        } else if (col.equals("green;red;green")) {
     97                                setColour(GREEN_RED_GREEN);
     98                                if (getRegion() == IALA_A)
     99                                        setBuoyIndex(PREF_STARBOARD_HAND);
     100                                else
     101                                        setBuoyIndex(PREF_PORT_HAND);
     102                        }
     103                } else if (cat.equals("port")) {
     104
     105                        setBuoyIndex(PORT_HAND);
     106
     107                        if (col.equals("red")) {
     108                                setRegion(SeaMark.IALA_A);
     109                                setColour(SeaMark.RED);
     110                        } else if (col.equals("green")) {
     111                                setRegion(SeaMark.IALA_B);
     112                                setColour(SeaMark.GREEN);
     113                        } else {
     114                                if (getRegion() == IALA_A)
     115                                        setColour(SeaMark.RED);
     116                                else
     117                                        setColour(SeaMark.GREEN);
     118                        }
     119                } else if (cat.compareTo("starboard") == 0) {
     120
     121                        setBuoyIndex(STARBOARD_HAND);
     122
     123                        if (col.compareTo("green") == 0) {
     124                                setRegion(SeaMark.IALA_A);
     125                                setColour(SeaMark.GREEN);
     126                        } else if (col.equals("red")) {
     127                                setRegion(SeaMark.IALA_B);
     128                                setColour(SeaMark.RED);
     129                        } else {
     130                                if (getRegion() == IALA_A)
     131                                        setColour(SeaMark.GREEN);
     132                                else
     133                                        setColour(SeaMark.RED);
     134                        }
     135                } else if (cat.compareTo("preferred_channel_port") == 0) {
     136
     137                        setBuoyIndex(PREF_PORT_HAND);
     138
     139                        if (col.compareTo("red;green;red") == 0) {
     140                                setRegion(SeaMark.IALA_A);
     141                                setColour(SeaMark.RED_GREEN_RED);
     142                        } else if (col.compareTo("green;red;green") == 0) {
     143                                setRegion(SeaMark.IALA_B);
     144                                setColour(SeaMark.GREEN_RED_GREEN);
     145                        } else {
     146                                if (getRegion() == IALA_A)
     147                                        setColour(SeaMark.RED_GREEN_RED);
     148                                else
     149                                        setColour(SeaMark.GREEN_RED_GREEN);
     150                        }
     151
     152                } else if (cat.compareTo("preferred_channel_starboard") == 0) {
     153
     154                        setBuoyIndex(PREF_STARBOARD_HAND);
     155
     156                        if (col.compareTo("green;red;green") == 0) {
     157                                setRegion(SeaMark.IALA_A);
     158                                setColour(SeaMark.GREEN_RED_GREEN);
     159                        } else if (col.compareTo("red;green;red") == 0) {
     160                                setRegion(SeaMark.IALA_B);
     161                                setColour(SeaMark.RED_GREEN_RED);
     162                        } else {
     163                                if (getRegion() == IALA_A)
     164                                        setColour(SeaMark.GREEN_RED_GREEN);
     165                                else
     166                                        setColour(SeaMark.RED_GREEN_RED);
     167                        }
     168                }
     169
    45170                refreshStyles();
    46 
    47                 paintSign();
    48         }
    49 
    50         public void refreshStyles() {
    51                 int type = getBuoyIndex();
    52                 int style = getStyleIndex();
    53 
    54                 dlg.cbM01StyleOfMark.removeAllItems();
    55                 dlg.cbM01StyleOfMark.addItem("Not set");
    56 
    57                 switch (type) {
    58                 case PORT_HAND:
    59                         dlg.cbM01StyleOfMark.addItem("Can Buoy");
    60                         dlg.cbM01StyleOfMark.addItem("Pillar Buoy");
    61                         dlg.cbM01StyleOfMark.addItem("Spar Buoy");
    62                         dlg.cbM01StyleOfMark.addItem("Beacon");
    63                         dlg.cbM01StyleOfMark.addItem("Tower");
    64                         dlg.cbM01StyleOfMark.addItem("Float");
    65                         dlg.cbM01StyleOfMark.addItem("Perch");
    66                         break;
    67 
    68                 case STARBOARD_HAND:
    69                         dlg.cbM01StyleOfMark.addItem("Cone Buoy");
    70                         dlg.cbM01StyleOfMark.addItem("Pillar Buoy");
    71                         dlg.cbM01StyleOfMark.addItem("Spar Buoy");
    72                         dlg.cbM01StyleOfMark.addItem("Beacon");
    73                         dlg.cbM01StyleOfMark.addItem("Tower");
    74                         dlg.cbM01StyleOfMark.addItem("Float");
    75                         dlg.cbM01StyleOfMark.addItem("Perch");
    76                         break;
    77 
    78                 case PREF_PORT_HAND:
    79                         dlg.cbM01StyleOfMark.addItem("Can Buoy");
    80                         dlg.cbM01StyleOfMark.addItem("Pillar Buoy");
    81                         dlg.cbM01StyleOfMark.addItem("Spar Buoy");
    82                         dlg.cbM01StyleOfMark.addItem("Beacon");
    83                         dlg.cbM01StyleOfMark.addItem("Tower");
    84                         dlg.cbM01StyleOfMark.addItem("Float");
    85                         break;
    86 
    87                 case PREF_STARBOARD_HAND:
    88                         dlg.cbM01StyleOfMark.addItem("Cone Buoy");
    89                         dlg.cbM01StyleOfMark.addItem("Pillar Buoy");
    90                         dlg.cbM01StyleOfMark.addItem("Spar Buoy");
    91                         dlg.cbM01StyleOfMark.addItem("Beacon");
    92                         dlg.cbM01StyleOfMark.addItem("Tower");
    93                         dlg.cbM01StyleOfMark.addItem("Float");
    94                         break;
    95 
    96                 default:
    97                 }
    98 
    99                 if (style >= dlg.cbM01StyleOfMark.getItemCount())
    100                         style = 0;
    101                 setStyleIndex(style);
    102                 dlg.cbM01StyleOfMark.setSelectedIndex(style);
    103 
    104         }
    105 
    106         public void paintSign() {
    107                 super.paintSign();
    108 
    109                 dlg.sM01StatusBar.setText(getErrMsg());
    110 
    111                 dlg.tfM01Name.setEnabled(true);
    112                 dlg.tfM01Name.setText(getName());
    113                 dlg.cM01Fired.setEnabled(true);
    114                 dlg.cM01TopMark.setEnabled(true);
    115 
    116                 String image = "/images/Lateral";
    117 
    118                 int cat = getBuoyIndex();
    119                 boolean region = getRegion();
    120                 int style = getStyleIndex();
    121 
    122                 switch (getBuoyIndex()) {
    123                 case SeaMark.PORT_HAND:
    124                         if (region != SeaMark.IALA_B)
    125                                 switch (style) {
    126                                 case LAT_CAN:
    127                                         image += "_Can_Red";
    128                                         break;
    129                                 case LAT_PILLAR:
    130                                         image += "_Pillar_Red";
    131                                         break;
    132                                 case LAT_SPAR:
    133                                         image += "_Spar_Red";
    134                                         break;
    135                                 case LAT_BEACON:
    136                                         image += "_Beacon_Red";
    137                                         break;
    138                                 case LAT_TOWER:
    139                                         image += "_Tower_Red";
    140                                         break;
    141                                 case LAT_FLOAT:
    142                                         image += "_Float_Red";
    143                                         break;
    144                                 case LAT_PERCH:
    145                                         image += "_Perch_Port";
    146                                         break;
    147                                 default:
    148                                 }
    149                         else
    150                                 switch (style) {
    151                                 case LAT_CAN:
    152                                         image += "_Can_Green";
    153                                         break;
    154                                 case LAT_PILLAR:
    155                                         image += "_Pillar_Green";
    156                                         break;
    157                                 case LAT_SPAR:
    158                                         image += "_Spar_Green";
    159                                         break;
    160                                 case LAT_BEACON:
    161                                         image += "_Beacon_Green";
    162                                         break;
    163                                 case LAT_TOWER:
    164                                         image += "_Tower_Green";
    165                                         break;
    166                                 case LAT_FLOAT:
    167                                         image += "_Float_Green";
    168                                         break;
    169                                 case LAT_PERCH:
    170                                         image += "_Perch_Port";
    171                                         break;
    172                                 default:
    173                                 }
    174                         break;
    175 
    176                 case SeaMark.STARBOARD_HAND:
    177                         if (region != SeaMark.IALA_B)
    178                                 switch (style) {
    179                                 case LAT_CONE:
    180                                         image += "_Cone_Green";
    181                                         break;
    182                                 case LAT_PILLAR:
    183                                         image += "_Pillar_Green";
    184                                         break;
    185                                 case LAT_SPAR:
    186                                         image += "_Spar_Green";
    187                                         break;
    188                                 case LAT_BEACON:
    189                                         image += "_Beacon_Green";
    190                                         break;
    191                                 case LAT_TOWER:
    192                                         image += "_Tower_Green";
    193                                         break;
    194                                 case LAT_FLOAT:
    195                                         image += "_Float_Green";
    196                                         break;
    197                                 case LAT_PERCH:
    198                                         image += "_Perch_Starboard";
    199                                         break;
    200                                 default:
    201                                 }
    202                         else
    203                                 switch (style) {
    204                                 case LAT_CONE:
    205                                         image += "_Cone_Red";
    206                                         break;
    207                                 case LAT_PILLAR:
    208                                         image += "_Pillar_Red";
    209                                         break;
    210                                 case LAT_SPAR:
    211                                         image += "_Spar_Red";
    212                                         break;
    213                                 case LAT_BEACON:
    214                                         image += "_Beacon_Red";
    215                                         break;
    216                                 case LAT_TOWER:
    217                                         image += "_Tower_Red";
    218                                         break;
    219                                 case LAT_FLOAT:
    220                                         image += "_Float_Red";
    221                                         break;
    222                                 case LAT_PERCH:
    223                                         image += "_Perch_Starboard";
    224                                         break;
    225                                 default:
    226                                 }
    227                         break;
    228 
    229                 case SeaMark.PREF_PORT_HAND:
    230                         if (region != SeaMark.IALA_B)
    231                                 switch (style) {
    232                                 case LAT_CAN:
    233                                         image += "_Can_Red_Green_Red";
    234                                         break;
    235                                 case LAT_PILLAR:
    236                                         image += "_Pillar_Red_Green_Red";
    237                                         break;
    238                                 case LAT_SPAR:
    239                                         image += "_Spar_Red_Green_Red";
    240                                         break;
    241                                 case LAT_BEACON:
    242                                         image += "_Beacon_Red_Green_Red";
    243                                         break;
    244                                 case LAT_TOWER:
    245                                         image += "_Tower_Red_Green_Red";
    246                                         break;
    247                                 case LAT_FLOAT:
    248                                         image += "_Float_Red_Green_Red";
    249                                         break;
    250                                 default:
    251                                 }
    252                         else
    253                                 switch (style) {
    254                                 case LAT_CAN:
    255                                         image += "_Can_Green_Red_Green";
    256                                         break;
    257                                 case LAT_PILLAR:
    258                                         image += "_Pillar_Green_Red_Green";
    259                                         break;
    260                                 case LAT_SPAR:
    261                                         image += "_Spar_Green_Red_Green";
    262                                         break;
    263                                 case LAT_BEACON:
    264                                         image += "_Beacon_Green_Red_Green";
    265                                         break;
    266                                 case LAT_TOWER:
    267                                         image += "_Tower_Green_Red_Green";
    268                                         break;
    269                                 case LAT_FLOAT:
    270                                         image += "_Float_Green_Red_Green";
    271                                         break;
    272                                 default:
    273                                 }
    274                         break;
    275 
    276                 case SeaMark.PREF_STARBOARD_HAND:
    277                         if (region != SeaMark.IALA_B)
    278                                 switch (style) {
    279                                 case LAT_CONE:
    280                                         image += "_Cone_Green_Red_Green";
    281                                         break;
    282                                 case LAT_PILLAR:
    283                                         image += "_Pillar_Green_Red_Green";
    284                                         break;
    285                                 case LAT_SPAR:
    286                                         image += "_Spar_Green_Red_Green";
    287                                         break;
    288                                 case LAT_BEACON:
    289                                         image += "_Beacon_Green_Red_Green";
    290                                         break;
    291                                 case LAT_TOWER:
    292                                         image += "_Tower_Green_Red_Green";
    293                                         break;
    294                                 case LAT_FLOAT:
    295                                         image += "_Float_Green_Red_Green";
    296                                         break;
    297                                 default:
    298                                 }
    299                         else
    300                                 switch (style) {
    301                                 case LAT_CONE:
    302                                         image += "_Cone_Red_Green_Red";
    303                                         break;
    304                                 case LAT_PILLAR:
    305                                         image += "_Pillar_Red_Green_Red";
    306                                         break;
    307                                 case LAT_SPAR:
    308                                         image += "_Spar_Red_Green_Red";
    309                                         break;
    310                                 case LAT_BEACON:
    311                                         image += "_Beacon_Red_Green_Red";
    312                                         break;
    313                                 case LAT_TOWER:
    314                                         image += "_Tower_Red_Green_Red";
    315                                         break;
    316                                 case LAT_FLOAT:
    317                                         image += "_Float_Red_Green_Red";
    318                                         break;
    319                                 default:
    320                                 }
    321                         break;
    322 
    323                 default:
    324                 }
    325 
    326                 if (image != "/images/Lateral") {
    327 
    328                         if (hasTopMark()) {
    329                                 if (cat == PORT_HAND || cat == PREF_PORT_HAND)
    330                                         image += "_Can";
    331                                 else
    332                                         image += "_Cone";
    333                         }
    334 
    335                         if (isFired())
    336                                 image += "_Lit";
    337                         if (getLightChar() != "") {
    338                                 String c;
    339 
    340                                 c = getLightChar();
    341                                 if (getLightGroup() != "")
    342                                         c = c + "(" + getLightGroup() + ")";
    343 
    344                                 dlg.cbM01Kennung.setSelectedItem(c);
    345                                 if (dlg.cbM01Kennung.getSelectedItem().equals("Not set"))
    346                                         c = "";
    347                         }
    348 
    349                         image += ".png";
    350 
    351                         dlg.lM01Icon01.setIcon(new ImageIcon(getClass().getResource(image)));
    352                 } else
    353                         dlg.lM01Icon01.setIcon(null);
    354         }
    355 
    356         public void saveSign() {
    357                 Node node = getNode();
    358 
    359                 if (node == null) {
    360                         return;
    361                 }
    362 
    363                 int cat = getBuoyIndex();
    364                 String shape = "";
    365                 String colour = "";
    366 
    367                 switch (cat) {
    368 
    369                 case PORT_HAND:
    370                         switch (getStyleIndex()) {
    371                         case LAT_CAN:
    372                                 super.saveSign("buoy_lateral");
    373                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    374                                                 "seamark:buoy_lateral:shape", "can"));
    375                                 break;
    376                         case LAT_PILLAR:
    377                                 super.saveSign("buoy_lateral");
    378                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    379                                                 "seamark:buoy_lateral:shape", "pillar"));
    380                                 break;
    381                         case LAT_SPAR:
    382                                 super.saveSign("buoy_lateral");
    383                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    384                                                 "seamark:buoy_lateral:shape", "spar"));
    385                                 break;
    386                         case LAT_BEACON:
    387                                 super.saveSign("beacon_lateral");
    388                                 break;
    389                         case LAT_TOWER:
    390                                 super.saveSign("beacon_lateral");
    391                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    392                                                 "seamark:beacon_lateral:shape", "tower"));
    393                                 break;
    394                         case LAT_FLOAT:
    395                                 super.saveSign("light_float");
    396                                 break;
    397                         case LAT_PERCH:
    398                                 super.saveSign("buoy_lateral");
    399                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    400                                                 "seamark:buoy_lateral:shape", "perch"));
    401                                 break;
    402                         default:
    403                         }
    404                         switch (getStyleIndex()) {
    405                         case LAT_CAN:
    406                         case LAT_PILLAR:
    407                         case LAT_SPAR:
    408                         case LAT_PERCH:
    409                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    410                                                 "seamark:buoy_lateral:category", "port"));
    411                                 if (getRegion() != SeaMark.IALA_B) {
    412                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    413                                                         "seamark:buoy_lateral:colour", "red"));
    414                                         colour = "red";
    415                                 } else {
    416                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    417                                                         "seamark:buoy_lateral:colour", "green"));
    418                                         colour = "green";
    419                                 }
    420                                 break;
    421                         case LAT_BEACON:
    422                         case LAT_TOWER:
    423                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    424                                                 "seamark:beacon_lateral:category", "port"));
    425                                 if (getRegion() != SeaMark.IALA_B) {
    426                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    427                                                         "seamark:beacon_lateral:colour", "red"));
    428                                         colour = "red";
    429                                 } else {
    430                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    431                                                         "seamark:beacon_lateral:colour", "green"));
    432                                         colour = "green";
    433                                 }
    434                                 break;
    435                         case LAT_FLOAT:
    436                                 if (getRegion() != SeaMark.IALA_B) {
    437                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    438                                                         "seamark:light_float:colour", "red"));
    439                                         colour = "red";
    440                                 } else {
    441                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    442                                                         "seamark:light_float:colour", "green"));
    443                                         colour = "green";
    444                                 }
    445                                 break;
    446                         }
    447                         shape = "cylinder";
    448                         break;
    449 
    450                 case PREF_PORT_HAND:
    451                         switch (getStyleIndex()) {
    452                         case LAT_CAN:
    453                                 super.saveSign("buoy_lateral");
    454                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    455                                                 "seamark:buoy_lateral:shape", "can"));
    456                                 break;
    457                         case LAT_PILLAR:
    458                                 super.saveSign("buoy_lateral");
    459                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    460                                                 "seamark:buoy_lateral:shape", "pillar"));
    461                                 break;
    462                         case LAT_SPAR:
    463                                 super.saveSign("buoy_lateral");
    464                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    465                                                 "seamark:buoy_lateral:shape", "spar"));
    466                                 break;
    467                         case LAT_BEACON:
    468                                 super.saveSign("beacon_lateral");
    469                                 break;
    470                         case LAT_TOWER:
    471                                 super.saveSign("beacon_lateral");
    472                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    473                                                 "seamark:beacon_lateral:shape", "tower"));
    474                                 break;
    475                         case LAT_FLOAT:
    476                                 super.saveSign("light_float");
    477                                 break;
    478                         default:
    479                         }
    480                         switch (getStyleIndex()) {
    481                         case LAT_CAN:
    482                         case LAT_PILLAR:
    483                         case LAT_SPAR:
    484                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    485                                                 "seamark:buoy_lateral:category", "preferred_channel_port"));
    486                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    487                                                 "seamark:buoy_lateral:colour_pattern", "horizontal stripes"));
    488                                 if (getRegion() != SeaMark.IALA_B) {
    489                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    490                                                         "seamark:buoy_lateral:colour", "red;green;red"));
    491                                         colour = "red";
    492                                 } else {
    493                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    494                                                         "seamark:buoy_lateral:colour", "green;red;green"));
    495                                         colour = "green";
    496                                 }
    497                                 break;
    498                         case LAT_BEACON:
    499                         case LAT_TOWER:
    500                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    501                                                 "seamark:beacon_lateral:category", "preferred_channel_port"));
    502                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    503                                                 "seamark:beacon_lateral:colour_pattern", "horizontal stripes"));
    504                                 if (getRegion() != SeaMark.IALA_B) {
    505                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    506                                                         "seamark:beacon_lateral:colour", "red;green;red"));
    507                                         colour = "red";
    508                                 } else {
    509                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    510                                                         "seamark:beacon_lateral:colour", "green;red;green"));
    511                                         colour = "green";
    512                                 }
    513                                 break;
    514                         case LAT_FLOAT:
    515                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    516                                                 "seamark:light_float:colour_pattern", "horizontal stripes"));
    517                                 if (getRegion() != SeaMark.IALA_B) {
    518                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    519                                                         "seamark:light_float:colour", "red;green;red"));
    520                                         colour = "red";
    521                                 } else {
    522                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    523                                                         "seamark:light_float:colour", "green;red;green"));
    524                                         colour = "green";
    525                                 }
    526                                 break;
    527                         }
    528                         shape = "cylinder";
    529                         break;
    530 
    531                 case STARBOARD_HAND:
    532                         switch (getStyleIndex()) {
    533                         case LAT_CONE:
    534                                 super.saveSign("buoy_lateral");
    535                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    536                                                 "seamark:buoy_lateral:shape", "conical"));
    537                                 break;
    538                         case LAT_PILLAR:
    539                                 super.saveSign("buoy_lateral");
    540                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    541                                                 "seamark:buoy_lateral:shape", "pillar"));
    542                                 break;
    543                         case LAT_SPAR:
    544                                 super.saveSign("buoy_lateral");
    545                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    546                                                 "seamark:buoy_lateral:shape", "spar"));
    547                                 break;
    548                         case LAT_BEACON:
    549                                 super.saveSign("beacon_lateral");
    550                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    551                                                 "seamark:beacon_lateral:shape", "stake"));
    552                                 break;
    553                         case LAT_TOWER:
    554                                 super.saveSign("beacon_lateral");
    555                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    556                                                 "seamark:beacon_lateral:shape", "tower"));
    557                                 break;
    558                         case LAT_FLOAT:
    559                                 super.saveSign("light_float");
    560                                 break;
    561                         case LAT_PERCH:
    562                                 super.saveSign("buoy_lateral");
    563                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    564                                                 "seamark:buoy_lateral:shape", "perch"));
    565                                 break;
    566                         default:
    567                         }
    568                         switch (getStyleIndex()) {
    569                         case LAT_CAN:
    570                         case LAT_PILLAR:
    571                         case LAT_SPAR:
    572                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    573                                                 "seamark:buoy_lateral:category", "starboard"));
    574                                 if (getRegion() != SeaMark.IALA_B) {
    575                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    576                                                         "seamark:buoy_lateral:colour", "green"));
    577                                         colour = "green";
    578                                 } else {
    579                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    580                                                         "seamark:buoy_lateral:colour", "red"));
    581                                         colour = "red";
    582                                 }
    583                                 break;
    584                         case LAT_BEACON:
    585                         case LAT_TOWER:
    586                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    587                                                 "seamark:beacon_lateral:category", "starboard"));
    588                                 if (getRegion() != SeaMark.IALA_B) {
    589                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    590                                                         "seamark:beacon_lateral:colour", "green"));
    591                                         colour = "green";
    592                                 } else {
    593                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    594                                                         "seamark:beacon_lateral:colour", "red"));
    595                                         colour = "red";
    596                                 }
    597                                 break;
    598                         case LAT_FLOAT:
    599                                 if (getRegion() != SeaMark.IALA_B) {
    600                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    601                                                         "seamark:light_float:colour", "green"));
    602                                         colour = "green";
    603                                 } else {
    604                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    605                                                         "seamark:light_float:colour", "red"));
    606                                         colour = "red";
    607                                 }
    608                                 break;
    609                         }
    610                         shape = "cone, point up";
    611                         break;
    612 
    613                 case PREF_STARBOARD_HAND:
    614                         switch (getStyleIndex()) {
    615                         case LAT_CONE:
    616                                 super.saveSign("buoy_lateral");
    617                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    618                                                 "seamark:buoy_lateral:shape", "conical"));
    619                                 break;
    620                         case LAT_PILLAR:
    621                                 super.saveSign("buoy_lateral");
    622                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    623                                                 "seamark:buoy_lateral:shape", "pillar"));
    624                                 break;
    625                         case LAT_SPAR:
    626                                 super.saveSign("buoy_lateral");
    627                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    628                                                 "seamark:buoy_lateral:shape", "spar"));
    629                                 break;
    630                         case LAT_BEACON:
    631                                 super.saveSign("beacon_lateral");
    632                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    633                                                 "seamark:beacon_lateral:shape", "stake"));
    634                                 break;
    635                         case LAT_TOWER:
    636                                 super.saveSign("beacon_lateral");
    637                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    638                                                 "seamark:beacon_lateral:shape", "tower"));
    639                                 break;
    640                         case LAT_FLOAT:
    641                                 super.saveSign("light_float");
    642                                 break;
    643                         default:
    644                         }
    645                         switch (getStyleIndex()) {
    646                         case LAT_CAN:
    647                         case LAT_PILLAR:
    648                         case LAT_SPAR:
    649                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    650                                                 "seamark:buoy_lateral:category", "preferred_channel_starboard"));
    651                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    652                                                 "seamark:buoy_lateral:colour_pattern", "horizontal stripes"));
    653                                 if (getRegion() != SeaMark.IALA_B) {
    654                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    655                                                         "seamark:buoy_lateral:colour", "green;red;green"));
    656                                         colour = "green";
    657                                 } else {
    658                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    659                                                         "seamark:buoy_lateral:colour", "red;green;red"));
    660                                         colour = "red";
    661                                 }
    662                                 break;
    663                         case LAT_BEACON:
    664                         case LAT_TOWER:
    665                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    666                                                 "seamark:beacon_lateral:category", "preferred_channel_starboard"));
    667                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    668                                                 "seamark:beacon_lateral:colour_pattern", "horizontal stripes"));
    669                                 if (getRegion() != SeaMark.IALA_B) {
    670                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    671                                                         "seamark:beacon_lateral:colour", "green;red;green"));
    672                                         colour = "green";
    673                                 } else {
    674                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    675                                                         "seamark:beacon_lateral:colour", "red;green;red"));
    676                                         colour = "red";
    677                                 }
    678                                 break;
    679                         case LAT_FLOAT:
    680                                 Main.main.undoRedo.add(new ChangePropertyCommand(node,
    681                                                 "seamark:light_float:colour_pattern", "horizontal stripes"));
    682                                 if (getRegion() != SeaMark.IALA_B) {
    683                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    684                                                         "seamark:light_float:colour", "green;red;green"));
    685                                         colour = "green";
    686                                 } else {
    687                                         Main.main.undoRedo.add(new ChangePropertyCommand(node,
    688                                                         "seamark:light_float:colour", "red;green;red"));
    689                                         colour = "red";
    690                                 }
    691                                 break;
    692                         }
    693                         shape = "cone, point up";
    694                         break;
    695 
    696                 default:
    697                 }
    698 
    699                 saveTopMarkData(shape, colour);
    700                 saveLightData(colour);
    701 
    702                 Main.pref.put("tomsplugin.IALA", getRegion() ? "B" : "A");
    703         }
    704 
    705         public boolean parseTopMark(Node node) {
    706                 if (node == null) {
    707                         return false;
    708                 }
    709 
    710                 String str;
    711                 boolean ret = true;
    712                 Map<String, String> keys;
    713 
    714                 keys = node.getKeys();
    715 
    716                 if (keys.containsKey("seamark:topmark:shape")) {
    717                         str = keys.get("seamark:topmark:shape");
    718 
    719                         int cat = getBuoyIndex();
    720                         switch (cat) {
    721                         case PORT_HAND:
    722                         case PREF_PORT_HAND:
    723                                 if (str.equals("cylinder")) {
    724                                         setTopMark(true);
    725                                         setRegion(IALA_A);
    726                                 } else if (str.equals("cone, point up")) {
    727                                         setTopMark(true);
    728                                         setRegion(IALA_B);
    729                                 } else {
    730                                         setTopMark(false);
    731                                         ret = false;
    732                                 }
    733                                 break;
    734 
    735                         case STARBOARD_HAND:
    736                         case PREF_STARBOARD_HAND:
    737                                 if (str.equals("cone, point up")) {
    738                                         setTopMark(true);
    739                                         setRegion(IALA_A);
    740                                 } else if (str.equals("cylinder")) {
    741                                         setTopMark(true);
    742                                         setRegion(IALA_B);
    743                                 } else {
    744                                         setTopMark(false);
    745                                         ret = false;
    746                                 }
    747                                 break;
    748 
    749                         default:
    750                                 ret = false;
    751                         }
    752                         if (!hasTopMark()) {
    753                                 setErrMsg("Parse-Error: Invalid topmark");
    754                                 ret = false;
    755                         }
    756                 }
    757                 return ret;
    758         }
    759 
    760         public boolean parseLight(Node node) {
    761                 String str;
    762                 boolean ret = true;
    763                 Map<String, String> keys;
    764 
    765                 setFired(false);
    766 
    767                 keys = node.getKeys();
    768 
    769                 if (keys.containsKey("seamark:light:colour")) {
    770                         str = keys.get("seamark:light:colour");
    771 
    772                         if (keys.containsKey("seamark:light:character")) {
    773                                 setLightGroup(keys);
    774                                 String c = keys.get("seamark:light:character");
    775                                 setLightChar(c);
    776                                 setLightPeriod(keys);
    777                         }
    778 
    779                         setLightColour(str);
    780 
    781                         if (isFired()) {
    782 
    783                         } else {
    784                                 if (getErrMsg() == null)
    785                                         setErrMsg("Parse-Error: Invalid light");
    786                                 else
    787                                         setErrMsg(getErrMsg() + " / Invalid light");
    788                         }
    789 
    790                 }
    791 
    792                 return ret;
    793         }
    794 
    795         public void setLightColour() {
    796                 if (getRegion() == IALA_A
    797                                 && (getBuoyIndex() == PORT_HAND || getBuoyIndex() == PREF_PORT_HAND)) {
    798                         super.setLightColour("R");
    799                 } else {
    800                         super.setLightColour("G");
    801                 }
    802         }
    803 
    804         public void setLightColour(String str) {
    805                 int cat = getBuoyIndex();
    806 
    807                 if (str == null) {
    808                         return;
    809                 }
    810 
    811                 switch (cat) {
    812                 case PORT_HAND:
    813                 case PREF_PORT_HAND:
    814                         if (getRegion() == IALA_A) {
    815                                 if (str.equals("red")) {
    816                                         setFired(true);
    817                                         super.setLightColour("R");
    818                                 } else {
    819                                         super.setLightColour("");
    820                                 }
    821                         } else {
    822                                 if (str.equals("green")) {
    823                                         setFired(true);
    824                                         super.setLightColour("G");
    825                                 } else {
    826                                         super.setLightColour("");
    827                                 }
    828                         }
    829                         break;
    830 
    831                 case STARBOARD_HAND:
    832                 case PREF_STARBOARD_HAND:
    833                         if (getRegion() == IALA_A) {
    834                                 if (str.equals("green")) {
    835                                         setFired(true);
    836                                         super.setLightColour("G");
    837                                 } else {
    838                                         super.setLightColour("");
    839                                 }
    840                         } else {
    841                                 if (str.equals("red")) {
    842                                         setFired(true);
    843                                         super.setLightColour("R");
    844                                 } else {
    845                                         super.setLightColour("");
    846                                 }
    847                         }
    848                         break;
    849 
    850                 default:
    851                 }
    852 
    853         }
    854 
    855         public boolean parseShape(Node node) {
    856                 String str;
    857                 boolean ret = true;
    858                 Map<String, String> keys;
    859 
    860                 keys = node.getKeys();
    861171
    862172                if (keys.containsKey("seamark:buoy_lateral:shape")) {
    863173                        str = keys.get("seamark:buoy_lateral:shape");
    864174
    865                         int cat = getBuoyIndex();
    866                         switch (cat) {
     175                        switch (getBuoyIndex()) {
    867176                        case PORT_HAND:
    868177                                if (str.compareTo("can") == 0)
     
    872181                                else if (str.compareTo("spar") == 0)
    873182                                        setStyleIndex(LAT_SPAR);
    874                                 else
    875                                         ret = false;
    876183                                break;
    877184
     
    883190                                else if (str.compareTo("spar") == 0)
    884191                                        setStyleIndex(LAT_SPAR);
    885                                 else
    886                                         ret = false;
    887192                                break;
    888193
     
    894199                                else if (str.compareTo("spar") == 0)
    895200                                        setStyleIndex(LAT_SPAR);
    896                                 else
    897                                         ret = false;
    898201                                break;
    899202
     
    905208                                else if (str.compareTo("spar") == 0)
    906209                                        setStyleIndex(LAT_SPAR);
    907                                 else
    908                                         ret = false;
    909                                 break;
    910 
    911                         default:
    912                                 ret = false;
     210                                break;
    913211                        }
    914212                } else if (keys.containsKey("seamark:beacon_lateral:colour")) {
     
    925223                        setStyleIndex(LAT_FLOAT);
    926224                }
    927                 return ret;
     225
     226                if (keys.containsKey("seamark:topmark:shape")) {
     227                        str = keys.get("seamark:topmark:shape");
     228
     229                        switch (getBuoyIndex()) {
     230                        case PORT_HAND:
     231                        case PREF_PORT_HAND:
     232                                if (str.equals("cylinder")) {
     233                                        setTopMark(true);
     234                                        setRegion(IALA_A);
     235                                } else if (str.equals("cone, point up")) {
     236                                        setTopMark(true);
     237                                        setRegion(IALA_B);
     238                                } else {
     239                                        setTopMark(false);
     240                                }
     241                                break;
     242
     243                        case STARBOARD_HAND:
     244                        case PREF_STARBOARD_HAND:
     245                                if (str.equals("cone, point up")) {
     246                                        setTopMark(true);
     247                                        setRegion(IALA_A);
     248                                } else if (str.equals("cylinder")) {
     249                                        setTopMark(true);
     250                                        setRegion(IALA_B);
     251                                } else {
     252                                        setTopMark(false);
     253                                }
     254                                break;
     255                        }
     256                }
     257
     258                if (keys.containsKey("seamark:light:colour")) {
     259                        setLightColour(keys.get("seamark:light:colour"));
     260                        setFired(true);
     261                }
     262
     263                if (keys.containsKey("seamark:light:character")) {
     264                        setLightGroup(keys);
     265                        setLightChar(keys.get("seamark:light:character"));
     266                        setLightPeriod(keys);
     267                }
     268
     269                paintSign();
    928270        }
     271
     272        public void refreshStyles() {
     273                int type = getBuoyIndex();
     274                int style = getStyleIndex();
     275
     276                dlg.cbM01StyleOfMark.removeAllItems();
     277                dlg.cbM01StyleOfMark.addItem("Not set");
     278
     279                switch (type) {
     280                case PORT_HAND:
     281                        dlg.cbM01StyleOfMark.addItem("Can Buoy");
     282                        dlg.cbM01StyleOfMark.addItem("Pillar Buoy");
     283                        dlg.cbM01StyleOfMark.addItem("Spar Buoy");
     284                        dlg.cbM01StyleOfMark.addItem("Beacon");
     285                        dlg.cbM01StyleOfMark.addItem("Tower");
     286                        dlg.cbM01StyleOfMark.addItem("Float");
     287                        dlg.cbM01StyleOfMark.addItem("Perch");
     288                        break;
     289
     290                case STARBOARD_HAND:
     291                        dlg.cbM01StyleOfMark.addItem("Cone Buoy");
     292                        dlg.cbM01StyleOfMark.addItem("Pillar Buoy");
     293                        dlg.cbM01StyleOfMark.addItem("Spar Buoy");
     294                        dlg.cbM01StyleOfMark.addItem("Beacon");
     295                        dlg.cbM01StyleOfMark.addItem("Tower");
     296                        dlg.cbM01StyleOfMark.addItem("Float");
     297                        dlg.cbM01StyleOfMark.addItem("Perch");
     298                        break;
     299
     300                case PREF_PORT_HAND:
     301                        dlg.cbM01StyleOfMark.addItem("Can Buoy");
     302                        dlg.cbM01StyleOfMark.addItem("Pillar Buoy");
     303                        dlg.cbM01StyleOfMark.addItem("Spar Buoy");
     304                        dlg.cbM01StyleOfMark.addItem("Beacon");
     305                        dlg.cbM01StyleOfMark.addItem("Tower");
     306                        dlg.cbM01StyleOfMark.addItem("Float");
     307                        break;
     308
     309                case PREF_STARBOARD_HAND:
     310                        dlg.cbM01StyleOfMark.addItem("Cone Buoy");
     311                        dlg.cbM01StyleOfMark.addItem("Pillar Buoy");
     312                        dlg.cbM01StyleOfMark.addItem("Spar Buoy");
     313                        dlg.cbM01StyleOfMark.addItem("Beacon");
     314                        dlg.cbM01StyleOfMark.addItem("Tower");
     315                        dlg.cbM01StyleOfMark.addItem("Float");
     316                        break;
     317
     318                default:
     319                }
     320
     321                if (style >= dlg.cbM01StyleOfMark.getItemCount())
     322                        style = 0;
     323                setStyleIndex(style);
     324                dlg.cbM01StyleOfMark.setSelectedIndex(style);
     325
     326        }
     327
     328        public void paintSign() {
     329                super.paintSign();
     330
     331                dlg.sM01StatusBar.setText(getErrMsg());
     332
     333                dlg.tfM01Name.setEnabled(true);
     334                dlg.tfM01Name.setText(getName());
     335                dlg.cM01Fired.setEnabled(true);
     336                dlg.cM01TopMark.setEnabled(true);
     337
     338                String image = "/images/Lateral";
     339
     340                int cat = getBuoyIndex();
     341                boolean region = getRegion();
     342                int style = getStyleIndex();
     343
     344                switch (getBuoyIndex()) {
     345                case SeaMark.PORT_HAND:
     346                        if (region != SeaMark.IALA_B)
     347                                switch (style) {
     348                                case LAT_CAN:
     349                                        image += "_Can_Red";
     350                                        break;
     351                                case LAT_PILLAR:
     352                                        image += "_Pillar_Red";
     353                                        break;
     354                                case LAT_SPAR:
     355                                        image += "_Spar_Red";
     356                                        break;
     357                                case LAT_BEACON:
     358                                        image += "_Beacon_Red";
     359                                        break;
     360                                case LAT_TOWER:
     361                                        image += "_Tower_Red";
     362                                        break;
     363                                case LAT_FLOAT:
     364                                        image += "_Float_Red";
     365                                        break;
     366                                case LAT_PERCH:
     367                                        image += "_Perch_Port";
     368                                        break;
     369                                default:
     370                                }
     371                        else
     372                                switch (style) {
     373                                case LAT_CAN:
     374                                        image += "_Can_Green";
     375                                        break;
     376                                case LAT_PILLAR:
     377                                        image += "_Pillar_Green";
     378                                        break;
     379                                case LAT_SPAR:
     380                                        image += "_Spar_Green";
     381                                        break;
     382                                case LAT_BEACON:
     383                                        image += "_Beacon_Green";
     384                                        break;
     385                                case LAT_TOWER:
     386                                        image += "_Tower_Green";
     387                                        break;
     388                                case LAT_FLOAT:
     389                                        image += "_Float_Green";
     390                                        break;
     391                                case LAT_PERCH:
     392                                        image += "_Perch_Port";
     393                                        break;
     394                                default:
     395                                }
     396                        break;
     397
     398                case SeaMark.STARBOARD_HAND:
     399                        if (region != SeaMark.IALA_B)
     400                                switch (style) {
     401                                case LAT_CONE:
     402                                        image += "_Cone_Green";
     403                                        break;
     404                                case LAT_PILLAR:
     405                                        image += "_Pillar_Green";
     406                                        break;
     407                                case LAT_SPAR:
     408                                        image += "_Spar_Green";
     409                                        break;
     410                                case LAT_BEACON:
     411                                        image += "_Beacon_Green";
     412                                        break;
     413                                case LAT_TOWER:
     414                                        image += "_Tower_Green";
     415                                        break;
     416                                case LAT_FLOAT:
     417                                        image += "_Float_Green";
     418                                        break;
     419                                case LAT_PERCH:
     420                                        image += "_Perch_Starboard";
     421                                        break;
     422                                default:
     423                                }
     424                        else
     425                                switch (style) {
     426                                case LAT_CONE:
     427                                        image += "_Cone_Red";
     428                                        break;
     429                                case LAT_PILLAR:
     430                                        image += "_Pillar_Red";
     431                                        break;
     432                                case LAT_SPAR:
     433                                        image += "_Spar_Red";
     434                                        break;
     435                                case LAT_BEACON:
     436                                        image += "_Beacon_Red";
     437                                        break;
     438                                case LAT_TOWER:
     439                                        image += "_Tower_Red";
     440                                        break;
     441                                case LAT_FLOAT:
     442                                        image += "_Float_Red";
     443                                        break;
     444                                case LAT_PERCH:
     445                                        image += "_Perch_Starboard";
     446                                        break;
     447                                default:
     448                                }
     449                        break;
     450
     451                case SeaMark.PREF_PORT_HAND:
     452                        if (region != SeaMark.IALA_B)
     453                                switch (style) {
     454                                case LAT_CAN:
     455                                        image += "_Can_Red_Green_Red";
     456                                        break;
     457                                case LAT_PILLAR:
     458                                        image += "_Pillar_Red_Green_Red";
     459                                        break;
     460                                case LAT_SPAR:
     461                                        image += "_Spar_Red_Green_Red";
     462                                        break;
     463                                case LAT_BEACON:
     464                                        image += "_Beacon_Red_Green_Red";
     465                                        break;
     466                                case LAT_TOWER:
     467                                        image += "_Tower_Red_Green_Red";
     468                                        break;
     469                                case LAT_FLOAT:
     470                                        image += "_Float_Red_Green_Red";
     471                                        break;
     472                                default:
     473                                }
     474                        else
     475                                switch (style) {
     476                                case LAT_CAN:
     477                                        image += "_Can_Green_Red_Green";
     478                                        break;
     479                                case LAT_PILLAR:
     480                                        image += "_Pillar_Green_Red_Green";
     481                                        break;
     482                                case LAT_SPAR:
     483                                        image += "_Spar_Green_Red_Green";
     484                                        break;
     485                                case LAT_BEACON:
     486                                        image += "_Beacon_Green_Red_Green";
     487                                        break;
     488                                case LAT_TOWER:
     489                                        image += "_Tower_Green_Red_Green";
     490                                        break;
     491                                case LAT_FLOAT:
     492                                        image += "_Float_Green_Red_Green";
     493                                        break;
     494                                default:
     495                                }
     496                        break;
     497
     498                case SeaMark.PREF_STARBOARD_HAND:
     499                        if (region != SeaMark.IALA_B)
     500                                switch (style) {
     501                                case LAT_CONE:
     502                                        image += "_Cone_Green_Red_Green";
     503                                        break;
     504                                case LAT_PILLAR:
     505                                        image += "_Pillar_Green_Red_Green";
     506                                        break;
     507                                case LAT_SPAR:
     508                                        image += "_Spar_Green_Red_Green";
     509                                        break;
     510                                case LAT_BEACON:
     511                                        image += "_Beacon_Green_Red_Green";
     512                                        break;
     513                                case LAT_TOWER:
     514                                        image += "_Tower_Green_Red_Green";
     515                                        break;
     516                                case LAT_FLOAT:
     517                                        image += "_Float_Green_Red_Green";
     518                                        break;
     519                                default:
     520                                }
     521                        else
     522                                switch (style) {
     523                                case LAT_CONE:
     524                                        image += "_Cone_Red_Green_Red";
     525                                        break;
     526                                case LAT_PILLAR:
     527                                        image += "_Pillar_Red_Green_Red";
     528                                        break;
     529                                case LAT_SPAR:
     530                                        image += "_Spar_Red_Green_Red";
     531                                        break;
     532                                case LAT_BEACON:
     533                                        image += "_Beacon_Red_Green_Red";
     534                                        break;
     535                                case LAT_TOWER:
     536                                        image += "_Tower_Red_Green_Red";
     537                                        break;
     538                                case LAT_FLOAT:
     539                                        image += "_Float_Red_Green_Red";
     540                                        break;
     541                                default:
     542                                }
     543                        break;
     544
     545                default:
     546                }
     547
     548                if (!image.equals("/images/Lateral")) {
     549
     550                        if (hasTopMark()) {
     551                                if (cat == PORT_HAND || cat == PREF_PORT_HAND)
     552                                        image += "_Can";
     553                                else
     554                                        image += "_Cone";
     555                        }
     556
     557                        if (isFired())
     558                                image += "_Lit";
     559                        if (getLightChar() != "") {
     560                                String c;
     561
     562                                c = getLightChar();
     563                                if (getLightGroup() != "")
     564                                        c = c + "(" + getLightGroup() + ")";
     565
     566                                dlg.cbM01Kennung.setSelectedItem(c);
     567                                if (dlg.cbM01Kennung.getSelectedItem().equals("Not set"))
     568                                        c = "";
     569                        }
     570
     571                        image += ".png";
     572
     573                        dlg.lM01Icon01.setIcon(new ImageIcon(getClass().getResource(image)));
     574                } else
     575                        dlg.lM01Icon01.setIcon(null);
     576        }
     577
     578        public void saveSign() {
     579                Node node = getNode();
     580
     581                if (node == null) {
     582                        return;
     583                }
     584
     585                int cat = getBuoyIndex();
     586                String shape = "";
     587                String colour = "";
     588
     589                switch (cat) {
     590
     591                case PORT_HAND:
     592                        switch (getStyleIndex()) {
     593                        case LAT_CAN:
     594                                super.saveSign("buoy_lateral");
     595                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     596                                                "seamark:buoy_lateral:shape", "can"));
     597                                break;
     598                        case LAT_PILLAR:
     599                                super.saveSign("buoy_lateral");
     600                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     601                                                "seamark:buoy_lateral:shape", "pillar"));
     602                                break;
     603                        case LAT_SPAR:
     604                                super.saveSign("buoy_lateral");
     605                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     606                                                "seamark:buoy_lateral:shape", "spar"));
     607                                break;
     608                        case LAT_BEACON:
     609                                super.saveSign("beacon_lateral");
     610                                break;
     611                        case LAT_TOWER:
     612                                super.saveSign("beacon_lateral");
     613                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     614                                                "seamark:beacon_lateral:shape", "tower"));
     615                                break;
     616                        case LAT_FLOAT:
     617                                super.saveSign("light_float");
     618                                break;
     619                        case LAT_PERCH:
     620                                super.saveSign("buoy_lateral");
     621                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     622                                                "seamark:buoy_lateral:shape", "perch"));
     623                                break;
     624                        default:
     625                        }
     626                        switch (getStyleIndex()) {
     627                        case LAT_CAN:
     628                        case LAT_PILLAR:
     629                        case LAT_SPAR:
     630                        case LAT_PERCH:
     631                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     632                                                "seamark:buoy_lateral:category", "port"));
     633                                if (getRegion() != SeaMark.IALA_B) {
     634                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     635                                                        "seamark:buoy_lateral:colour", "red"));
     636                                        colour = "red";
     637                                } else {
     638                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     639                                                        "seamark:buoy_lateral:colour", "green"));
     640                                        colour = "green";
     641                                }
     642                                break;
     643                        case LAT_BEACON:
     644                        case LAT_TOWER:
     645                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     646                                                "seamark:beacon_lateral:category", "port"));
     647                                if (getRegion() != SeaMark.IALA_B) {
     648                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     649                                                        "seamark:beacon_lateral:colour", "red"));
     650                                        colour = "red";
     651                                } else {
     652                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     653                                                        "seamark:beacon_lateral:colour", "green"));
     654                                        colour = "green";
     655                                }
     656                                break;
     657                        case LAT_FLOAT:
     658                                if (getRegion() != SeaMark.IALA_B) {
     659                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     660                                                        "seamark:light_float:colour", "red"));
     661                                        colour = "red";
     662                                } else {
     663                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     664                                                        "seamark:light_float:colour", "green"));
     665                                        colour = "green";
     666                                }
     667                                break;
     668                        }
     669                        shape = "cylinder";
     670                        break;
     671
     672                case PREF_PORT_HAND:
     673                        switch (getStyleIndex()) {
     674                        case LAT_CAN:
     675                                super.saveSign("buoy_lateral");
     676                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     677                                                "seamark:buoy_lateral:shape", "can"));
     678                                break;
     679                        case LAT_PILLAR:
     680                                super.saveSign("buoy_lateral");
     681                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     682                                                "seamark:buoy_lateral:shape", "pillar"));
     683                                break;
     684                        case LAT_SPAR:
     685                                super.saveSign("buoy_lateral");
     686                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     687                                                "seamark:buoy_lateral:shape", "spar"));
     688                                break;
     689                        case LAT_BEACON:
     690                                super.saveSign("beacon_lateral");
     691                                break;
     692                        case LAT_TOWER:
     693                                super.saveSign("beacon_lateral");
     694                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     695                                                "seamark:beacon_lateral:shape", "tower"));
     696                                break;
     697                        case LAT_FLOAT:
     698                                super.saveSign("light_float");
     699                                break;
     700                        default:
     701                        }
     702                        switch (getStyleIndex()) {
     703                        case LAT_CAN:
     704                        case LAT_PILLAR:
     705                        case LAT_SPAR:
     706                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     707                                                "seamark:buoy_lateral:category", "preferred_channel_port"));
     708                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     709                                                "seamark:buoy_lateral:colour_pattern", "horizontal stripes"));
     710                                if (getRegion() != SeaMark.IALA_B) {
     711                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     712                                                        "seamark:buoy_lateral:colour", "red;green;red"));
     713                                        colour = "red";
     714                                } else {
     715                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     716                                                        "seamark:buoy_lateral:colour", "green;red;green"));
     717                                        colour = "green";
     718                                }
     719                                break;
     720                        case LAT_BEACON:
     721                        case LAT_TOWER:
     722                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     723                                                "seamark:beacon_lateral:category", "preferred_channel_port"));
     724                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     725                                                "seamark:beacon_lateral:colour_pattern", "horizontal stripes"));
     726                                if (getRegion() != SeaMark.IALA_B) {
     727                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     728                                                        "seamark:beacon_lateral:colour", "red;green;red"));
     729                                        colour = "red";
     730                                } else {
     731                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     732                                                        "seamark:beacon_lateral:colour", "green;red;green"));
     733                                        colour = "green";
     734                                }
     735                                break;
     736                        case LAT_FLOAT:
     737                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     738                                                "seamark:light_float:colour_pattern", "horizontal stripes"));
     739                                if (getRegion() != SeaMark.IALA_B) {
     740                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     741                                                        "seamark:light_float:colour", "red;green;red"));
     742                                        colour = "red";
     743                                } else {
     744                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     745                                                        "seamark:light_float:colour", "green;red;green"));
     746                                        colour = "green";
     747                                }
     748                                break;
     749                        }
     750                        shape = "cylinder";
     751                        break;
     752
     753                case STARBOARD_HAND:
     754                        switch (getStyleIndex()) {
     755                        case LAT_CONE:
     756                                super.saveSign("buoy_lateral");
     757                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     758                                                "seamark:buoy_lateral:shape", "conical"));
     759                                break;
     760                        case LAT_PILLAR:
     761                                super.saveSign("buoy_lateral");
     762                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     763                                                "seamark:buoy_lateral:shape", "pillar"));
     764                                break;
     765                        case LAT_SPAR:
     766                                super.saveSign("buoy_lateral");
     767                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     768                                                "seamark:buoy_lateral:shape", "spar"));
     769                                break;
     770                        case LAT_BEACON:
     771                                super.saveSign("beacon_lateral");
     772                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     773                                                "seamark:beacon_lateral:shape", "stake"));
     774                                break;
     775                        case LAT_TOWER:
     776                                super.saveSign("beacon_lateral");
     777                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     778                                                "seamark:beacon_lateral:shape", "tower"));
     779                                break;
     780                        case LAT_FLOAT:
     781                                super.saveSign("light_float");
     782                                break;
     783                        case LAT_PERCH:
     784                                super.saveSign("buoy_lateral");
     785                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     786                                                "seamark:buoy_lateral:shape", "perch"));
     787                                break;
     788                        default:
     789                        }
     790                        switch (getStyleIndex()) {
     791                        case LAT_CAN:
     792                        case LAT_PILLAR:
     793                        case LAT_SPAR:
     794                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     795                                                "seamark:buoy_lateral:category", "starboard"));
     796                                if (getRegion() != SeaMark.IALA_B) {
     797                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     798                                                        "seamark:buoy_lateral:colour", "green"));
     799                                        colour = "green";
     800                                } else {
     801                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     802                                                        "seamark:buoy_lateral:colour", "red"));
     803                                        colour = "red";
     804                                }
     805                                break;
     806                        case LAT_BEACON:
     807                        case LAT_TOWER:
     808                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     809                                                "seamark:beacon_lateral:category", "starboard"));
     810                                if (getRegion() != SeaMark.IALA_B) {
     811                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     812                                                        "seamark:beacon_lateral:colour", "green"));
     813                                        colour = "green";
     814                                } else {
     815                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     816                                                        "seamark:beacon_lateral:colour", "red"));
     817                                        colour = "red";
     818                                }
     819                                break;
     820                        case LAT_FLOAT:
     821                                if (getRegion() != SeaMark.IALA_B) {
     822                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     823                                                        "seamark:light_float:colour", "green"));
     824                                        colour = "green";
     825                                } else {
     826                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     827                                                        "seamark:light_float:colour", "red"));
     828                                        colour = "red";
     829                                }
     830                                break;
     831                        }
     832                        shape = "cone, point up";
     833                        break;
     834
     835                case PREF_STARBOARD_HAND:
     836                        switch (getStyleIndex()) {
     837                        case LAT_CONE:
     838                                super.saveSign("buoy_lateral");
     839                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     840                                                "seamark:buoy_lateral:shape", "conical"));
     841                                break;
     842                        case LAT_PILLAR:
     843                                super.saveSign("buoy_lateral");
     844                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     845                                                "seamark:buoy_lateral:shape", "pillar"));
     846                                break;
     847                        case LAT_SPAR:
     848                                super.saveSign("buoy_lateral");
     849                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     850                                                "seamark:buoy_lateral:shape", "spar"));
     851                                break;
     852                        case LAT_BEACON:
     853                                super.saveSign("beacon_lateral");
     854                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     855                                                "seamark:beacon_lateral:shape", "stake"));
     856                                break;
     857                        case LAT_TOWER:
     858                                super.saveSign("beacon_lateral");
     859                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     860                                                "seamark:beacon_lateral:shape", "tower"));
     861                                break;
     862                        case LAT_FLOAT:
     863                                super.saveSign("light_float");
     864                                break;
     865                        default:
     866                        }
     867                        switch (getStyleIndex()) {
     868                        case LAT_CAN:
     869                        case LAT_PILLAR:
     870                        case LAT_SPAR:
     871                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     872                                                "seamark:buoy_lateral:category", "preferred_channel_starboard"));
     873                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     874                                                "seamark:buoy_lateral:colour_pattern", "horizontal stripes"));
     875                                if (getRegion() != SeaMark.IALA_B) {
     876                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     877                                                        "seamark:buoy_lateral:colour", "green;red;green"));
     878                                        colour = "green";
     879                                } else {
     880                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     881                                                        "seamark:buoy_lateral:colour", "red;green;red"));
     882                                        colour = "red";
     883                                }
     884                                break;
     885                        case LAT_BEACON:
     886                        case LAT_TOWER:
     887                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     888                                                "seamark:beacon_lateral:category", "preferred_channel_starboard"));
     889                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     890                                                "seamark:beacon_lateral:colour_pattern", "horizontal stripes"));
     891                                if (getRegion() != SeaMark.IALA_B) {
     892                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     893                                                        "seamark:beacon_lateral:colour", "green;red;green"));
     894                                        colour = "green";
     895                                } else {
     896                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     897                                                        "seamark:beacon_lateral:colour", "red;green;red"));
     898                                        colour = "red";
     899                                }
     900                                break;
     901                        case LAT_FLOAT:
     902                                Main.main.undoRedo.add(new ChangePropertyCommand(node,
     903                                                "seamark:light_float:colour_pattern", "horizontal stripes"));
     904                                if (getRegion() != SeaMark.IALA_B) {
     905                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     906                                                        "seamark:light_float:colour", "green;red;green"));
     907                                        colour = "green";
     908                                } else {
     909                                        Main.main.undoRedo.add(new ChangePropertyCommand(node,
     910                                                        "seamark:light_float:colour", "red;green;red"));
     911                                        colour = "red";
     912                                }
     913                                break;
     914                        }
     915                        shape = "cone, point up";
     916                        break;
     917
     918                default:
     919                }
     920
     921                saveTopMarkData(shape, colour);
     922                saveLightData(colour);
     923
     924                Main.pref.put("tomsplugin.IALA", getRegion() ? "B" : "A");
     925        }
     926
     927        public void setLightColour() {
     928                if (getRegion() == IALA_A
     929                                && (getBuoyIndex() == PORT_HAND || getBuoyIndex() == PREF_PORT_HAND)) {
     930                        super.setLightColour("R");
     931                } else {
     932                        super.setLightColour("G");
     933                }
     934        }
     935
     936        public void setLightColour(String str) {
     937                int cat = getBuoyIndex();
     938
     939                if (str == null) {
     940                        return;
     941                }
     942
     943                switch (cat) {
     944                case PORT_HAND:
     945                case PREF_PORT_HAND:
     946                        if (getRegion() == IALA_A) {
     947                                if (str.equals("red")) {
     948                                        setFired(true);
     949                                        super.setLightColour("R");
     950                                } else {
     951                                        super.setLightColour("");
     952                                }
     953                        } else {
     954                                if (str.equals("green")) {
     955                                        setFired(true);
     956                                        super.setLightColour("G");
     957                                } else {
     958                                        super.setLightColour("");
     959                                }
     960                        }
     961                        break;
     962
     963                case STARBOARD_HAND:
     964                case PREF_STARBOARD_HAND:
     965                        if (getRegion() == IALA_A) {
     966                                if (str.equals("green")) {
     967                                        setFired(true);
     968                                        super.setLightColour("G");
     969                                } else {
     970                                        super.setLightColour("");
     971                                }
     972                        } else {
     973                                if (str.equals("red")) {
     974                                        setFired(true);
     975                                        super.setLightColour("R");
     976                                } else {
     977                                        super.setLightColour("");
     978                                }
     979                        }
     980                        break;
     981
     982                default:
     983                }
     984
     985        }
     986
    929987}
Note: See TracChangeset for help on using the changeset viewer.