forester/java/src/org/forester/archaeopteryx/NodeEditPanel.java

   1 // $Id:
   2 // FORESTER -- software libraries and applications
   3 // for evolutionary biology research and applications.
   4 //
   5 // Copyright (C) 2008-2009 Christian M. Zmasek
   6 // Copyright (C) 2008-2009 Burnham Institute for Medical Research
   7 // All rights reserved
   8 //
   9 // This library is free software; you can redistribute it and/or
  10 // modify it under the terms of the GNU Lesser General Public
  11 // License as published by the Free Software Foundation; either
  12 // version 2.1 of the License, or (at your option) any later version.
  13 //
  14 // This library is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17 // Lesser General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU Lesser General Public
  20 // License along with this library; if not, write to the Free Software
  21 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  22 //
  23 // Contact: phylosoft @ gmail . com
  24 // WWW: www.phylosoft.org/
  25
  26 package org.forester.archaeopteryx;
  27
  28 import java.awt.event.KeyEvent;
  29 import java.awt.event.KeyListener;
  30 import java.math.BigDecimal;
  31 import java.net.URL;
  32 import java.text.ParseException;
  33 import java.util.ArrayList;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37
  38 import javax.swing.JEditorPane;
  39 import javax.swing.JOptionPane;
  40 import javax.swing.JPanel;
  41 import javax.swing.JScrollPane;
  42 import javax.swing.JSplitPane;
  43 import javax.swing.JTree;
  44 import javax.swing.event.TreeSelectionEvent;
  45 import javax.swing.event.TreeSelectionListener;
  46 import javax.swing.text.Position;
  47 import javax.swing.tree.DefaultMutableTreeNode;
  48 import javax.swing.tree.TreePath;
  49 import javax.swing.tree.TreeSelectionModel;
  50
  51 import org.forester.archaeopteryx.tools.ImageLoader;
  52 import org.forester.io.parsers.phyloxml.PhyloXmlDataFormatException;
  53 import org.forester.phylogeny.PhylogenyNode;
  54 import org.forester.phylogeny.data.Accession;
  55 import org.forester.phylogeny.data.BranchWidth;
  56 import org.forester.phylogeny.data.Confidence;
  57 import org.forester.phylogeny.data.Date;
  58 import org.forester.phylogeny.data.Distribution;
  59 import org.forester.phylogeny.data.Event;
  60 import org.forester.phylogeny.data.Identifier;
  61 import org.forester.phylogeny.data.MultipleUris;
  62 import org.forester.phylogeny.data.PhylogenyData;
  63 import org.forester.phylogeny.data.PhylogenyDataUtil;
  64 import org.forester.phylogeny.data.Point;
  65 import org.forester.phylogeny.data.Reference;
  66 import org.forester.phylogeny.data.Sequence;
  67 import org.forester.phylogeny.data.Taxonomy;
  68 import org.forester.phylogeny.data.Uri;
  69 import org.forester.util.FailedConditionCheckException;
  70 import org.forester.util.ForesterUtil;
  71
  72 class NodeEditPanel extends JPanel {
  73
  74     private static final long                            serialVersionUID = 5120159904388100771L;
  75     private final JTree                                  _tree;
  76     private final JEditorPane                            _pane;
  77     private final PhylogenyNode                          _my_node;
  78     private final TreePanel                              _tree_panel;
  79     private final Map<DefaultMutableTreeNode, TagNumber> _map;
  80
  81     public NodeEditPanel( final PhylogenyNode phylogeny_node, final TreePanel tree_panel ) {
  82         _map = new HashMap<DefaultMutableTreeNode, TagNumber>();
  83         _my_node = phylogeny_node;
  84         _tree_panel = tree_panel;
  85         String node_name = "";
  86         if ( !ForesterUtil.isEmpty( phylogeny_node.getName() ) ) {
  87             node_name = phylogeny_node.getName() + " ";
  88         }
  89         final DefaultMutableTreeNode top = new DefaultMutableTreeNode( "Node " + node_name );
  90         createNodes( top, phylogeny_node );
  91         _tree = new JTree( top );
  92         getJTree().setEditable( true );
  93         getJTree().setFocusable( true );
  94         getJTree().setToggleClickCount( 1 );
  95         getJTree().setInvokesStopCellEditing( true );
  96         final JScrollPane tree_view = new JScrollPane( getJTree() );
  97         _pane = new JEditorPane();
  98         _pane.setEditable( true );
  99         final JScrollPane data_view = new JScrollPane( _pane );
 100         final JSplitPane split_pane = new JSplitPane( JSplitPane.VERTICAL_SPLIT );
 101         split_pane.setTopComponent( tree_view );
 102         // split_pane.setBottomComponent( data_view );
 103         data_view.setMinimumSize( Constants.NODE_PANEL_SPLIT_MINIMUM_SIZE );
 104         tree_view.setMinimumSize( Constants.NODE_PANEL_SPLIT_MINIMUM_SIZE );
 105         // split_pane.setDividerLocation( 400 );
 106         split_pane.setPreferredSize( Constants.NODE_PANEL_SIZE );
 107         add( split_pane );
 108         getJTree().getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION );
 109         getJTree().addKeyListener( new KeyListener() {
 110
 111             @Override
 112             public void keyPressed( final KeyEvent e ) {
 113                 keyEvent( e );
 114             }
 115
 116             @Override
 117             public void keyReleased( final KeyEvent e ) {
 118                 keyEvent( e );
 119             }
 120
 121             @Override
 122             public void keyTyped( final KeyEvent e ) {
 123                 keyEvent( e );
 124             }
 125         } );
 126         for( int i = 0; i < getJTree().getRowCount(); i++ ) {
 127             getJTree().expandRow( i );
 128         }
 129         collapsePath( NodePanel.BASIC );
 130         collapsePath( NodePanel.TAXONOMY );
 131         collapsePath( NodePanel.SEQUENCE );
 132         collapsePath( NodePanel.EVENTS );
 133         collapsePath( NodePanel.DATE );
 134         collapsePath( NodePanel.DISTRIBUTION );
 135         collapsePath( NodePanel.LIT_REFERENCE );
 136         getJTree().addTreeSelectionListener( new TreeSelectionListener() {
 137
 138             @Override
 139             public void valueChanged( final TreeSelectionEvent e ) {
 140                 final TreePath new_path = e.getNewLeadSelectionPath();
 141                 final TreePath old_path = e.getOldLeadSelectionPath();
 142                 if ( new_path != null ) {
 143                     writeBack( ( DefaultMutableTreeNode ) new_path.getLastPathComponent() );
 144                 }
 145                 if ( old_path != null ) {
 146                     writeBack( ( DefaultMutableTreeNode ) old_path.getLastPathComponent() );
 147                 }
 148             }
 149         } );
 150     }
 151
 152     private void addBasics( final DefaultMutableTreeNode top, final PhylogenyNode phylogeny_node, final String name ) {
 153         final DefaultMutableTreeNode category = new DefaultMutableTreeNode( name );
 154         top.add( category );
 155         addSubelementEditable( category, NodePanel.NODE_NAME, phylogeny_node.getName(), PHYLOXML_TAG.NODE_NAME );
 156         String bl = "";
 157         if ( phylogeny_node.getDistanceToParent() != PhylogenyDataUtil.BRANCH_LENGTH_DEFAULT ) {
 158             bl = ForesterUtil.FORMATTER_6.format( phylogeny_node.getDistanceToParent() );
 159         }
 160         addSubelementEditable( category, NodePanel.NODE_BRANCH_LENGTH, bl, PHYLOXML_TAG.NODE_BRANCH_LENGTH );
 161         int counter = 0;
 162         if ( phylogeny_node.getBranchData().isHasConfidences() ) {
 163             for( int i = phylogeny_node.getBranchData().getConfidences().size() - 1; i >= 0; i-- ) {
 164                 if ( phylogeny_node.getBranchData().getConfidences().get( i ).getValue() == Confidence.CONFIDENCE_DEFAULT_VALUE ) {
 165                     phylogeny_node.getBranchData().getConfidences().remove( i );
 166                 }
 167             }
 168             for( final PhylogenyData conf : phylogeny_node.getBranchData().getConfidences() ) {
 169                 final Confidence my_conf = ( Confidence ) ( conf );
 170                 addSubelementEditable( category,
 171                                        NodePanel.CONFIDENCE + " [" + counter + "]",
 172                                        ForesterUtil.FORMATTER_6.format( my_conf.getValue() ),
 173                                        PHYLOXML_TAG.CONFIDENCE_VALUE,
 174                                        NodePanel.CONFIDENCE_TYPE,
 175                                        my_conf.getType(),
 176                                        PHYLOXML_TAG.CONFIDENCE_TYPE,
 177                                        counter++ );
 178             }
 179         }
 180         addSubelementEditable( category,
 181                                NodePanel.CONFIDENCE + " [" + counter + "]",
 182                                "",
 183                                PHYLOXML_TAG.CONFIDENCE_VALUE,
 184                                NodePanel.CONFIDENCE_TYPE,
 185                                "",
 186                                PHYLOXML_TAG.CONFIDENCE_TYPE,
 187                                counter );
 188         String bw = "1";
 189         if ( ( phylogeny_node.getBranchData().getBranchWidth() != null )
 190                 && ( phylogeny_node.getBranchData().getBranchWidth().getValue() != BranchWidth.BRANCH_WIDTH_DEFAULT_VALUE ) ) {
 191             bw = ForesterUtil.FORMATTER_3.format( phylogeny_node.getBranchData().getBranchWidth().getValue() );
 192         }
 193         addSubelementEditable( category, NodePanel.NODE_BRANCH_WIDTH, bw, PHYLOXML_TAG.NODE_BRANCH_WIDTH );
 194     }
 195
 196     //    private void addAnnotation( final DefaultMutableTreeNode top, final Annotation ann, final String name ) {
 197     //        DefaultMutableTreeNode category;
 198     //        category = new DefaultMutableTreeNode( name );
 199     //        top.add( category );
 200     //        addSubelementEditable( category, "Reference", ann.getRef() , PHYLOXML_TAG.);
 201     //        addSubelementEditable( category, "Description", ann.getDesc() , PHYLOXML_TAG.);
 202     //        addSubelementEditable( category, "Source", ann.getSource(), PHYLOXML_TAG. );
 203     //        addSubelementEditable( category, "Type", ann.getType(), PHYLOXML_TAG. );
 204     //        addSubelementEditable( category, "Evidence", ann.getEvidence() , PHYLOXML_TAG.);
 205     //        if ( ann.getConfidence() != null ) {
 206     //            addSubelementEditable( category, "Confidence", ann.getConfidence().asText().toString() , PHYLOXML_TAG.);
 207     //        }
 208     //        if ( ann.getProperties() != null ) {
 209     //            addProperties( category, ann.getProperties(), "Properties", PHYLOXML_TAG. );
 210     //        }
 211     //    }
 212     //    private void addAnnotations( final DefaultMutableTreeNode top,
 213     //                                 final List<PhylogenyData> annotations,
 214     //                                 final DefaultMutableTreeNode category ) {
 215     //        if ( ( annotations != null ) && ( annotations.size() > 0 ) ) {
 216     //            category.add( new DefaultMutableTreeNode( "Annotations" ) );
 217     //            final DefaultMutableTreeNode last = top.getLastLeaf();
 218     //            int i = 0;
 219     //            for( final PhylogenyData ann : annotations ) {
 220     //                addAnnotation( last, ( Annotation ) ann, "Annotation " + ( i++ ) );
 221     //            }
 222     //        }
 223     //    }
 224     private void addDate( final DefaultMutableTreeNode top, Date date, final String name ) {
 225         if ( date == null ) {
 226             date = new Date();
 227         }
 228         DefaultMutableTreeNode category;
 229         category = new DefaultMutableTreeNode( name );
 230         top.add( category );
 231         addSubelementEditable( category, NodePanel.DATE_DESCRIPTION, date.getDesc(), PHYLOXML_TAG.DATE_DESCRIPTION );
 232         addSubelementEditable( category,
 233                                NodePanel.DATE_VALUE,
 234                                String.valueOf( date.getValue() != null ? date.getValue() : "" ),
 235                                PHYLOXML_TAG.DATE_VALUE );
 236         addSubelementEditable( category,
 237                                NodePanel.DATE_MIN,
 238                                String.valueOf( date.getMin() != null ? date.getMin() : "" ),
 239                                PHYLOXML_TAG.DATE_MIN );
 240         addSubelementEditable( category,
 241                                NodePanel.DATE_MAX,
 242                                String.valueOf( date.getMax() != null ? date.getMax() : "" ),
 243                                PHYLOXML_TAG.DATE_MAX );
 244         addSubelementEditable( category, NodePanel.DATE_UNIT, date.getUnit(), PHYLOXML_TAG.DATE_UNIT );
 245     }
 246
 247     private void addDistribution( final DefaultMutableTreeNode top, Distribution dist, final String name ) {
 248         if ( dist == null ) {
 249             dist = new Distribution( "" );
 250         }
 251         final DefaultMutableTreeNode category = new DefaultMutableTreeNode( name );
 252         top.add( category );
 253         Point p0 = null;
 254         if ( ( dist.getPoints() != null ) && ( dist.getPoints().size() > 0 ) ) {
 255             p0 = dist.getPoints().get( 0 );
 256         }
 257         else {
 258             p0 = new Point();
 259         }
 260         addSubelementEditable( category, NodePanel.DIST_DESCRIPTION, dist.getDesc(), PHYLOXML_TAG.DIST_DESC );
 261         addSubelementEditable( category,
 262                                NodePanel.DIST_GEODETIC_DATUM,
 263                                p0.getGeodeticDatum(),
 264                                PHYLOXML_TAG.DIST_GEODETIC );
 265         addSubelementEditable( category,
 266                                NodePanel.DIST_LATITUDE,
 267                                String.valueOf( p0.getLatitude() != null ? p0.getLatitude() : "" ),
 268                                PHYLOXML_TAG.DIST_LAT );
 269         addSubelementEditable( category,
 270                                NodePanel.DIST_LONGITUDE,
 271                                String.valueOf( p0.getLongitude() != null ? p0.getLongitude() : "" ),
 272                                PHYLOXML_TAG.DIST_LONG );
 273         addSubelementEditable( category,
 274                                NodePanel.DIST_ALTITUDE,
 275                                String.valueOf( p0.getAltitude() != null ? p0.getAltitude() : "" ),
 276                                PHYLOXML_TAG.DIST_ALT );
 277         addSubelementEditable( category,
 278                                NodePanel.DIST_ALT_UNIT,
 279                                String.valueOf( p0.getAltiudeUnit() != null ? p0.getAltiudeUnit() : "" ),
 280                                PHYLOXML_TAG.DIST_ALT_UNIT );
 281     }
 282
 283     private void addEvents( final DefaultMutableTreeNode top, Event events, final String name ) {
 284         final DefaultMutableTreeNode category = new DefaultMutableTreeNode( name );
 285         if ( events == null ) {
 286             events = new Event();
 287         }
 288         top.add( category );
 289         addSubelementEditable( category,
 290                                NodePanel.EVENTS_DUPLICATIONS,
 291                                String.valueOf( events.getNumberOfDuplications() >= 0 ? events.getNumberOfDuplications()
 292                                        : 0 ),
 293                                PHYLOXML_TAG.EVENTS_DUPLICATIONS );
 294         addSubelementEditable( category,
 295                                NodePanel.EVENTS_SPECIATIONS,
 296                                String.valueOf( events.getNumberOfSpeciations() >= 0 ? events.getNumberOfSpeciations()
 297                                        : 0 ),
 298                                PHYLOXML_TAG.EVENTS_SPECIATIONS );
 299         addSubelementEditable( category,
 300                                NodePanel.EVENTS_GENE_LOSSES,
 301                                String.valueOf( events.getNumberOfGeneLosses() >= 0 ? events.getNumberOfGeneLosses() : 0 ),
 302                                PHYLOXML_TAG.EVENTS_GENE_LOSSES );
 303     }
 304
 305     private void addMapping( final DefaultMutableTreeNode mtn, final TagNumber tag ) {
 306         if ( getMap().containsKey( mtn ) ) {
 307             throw new IllegalArgumentException( "key " + mtn + " already present" );
 308         }
 309         if ( getMap().containsValue( tag ) ) {
 310             throw new IllegalArgumentException( "value " + tag + " already present" );
 311         }
 312         getMap().put( mtn, tag );
 313     }
 314
 315     private void addReference( final DefaultMutableTreeNode top, Reference ref, final String name ) {
 316         if ( ref == null ) {
 317             ref = new Reference( "" );
 318         }
 319         final DefaultMutableTreeNode category = new DefaultMutableTreeNode( name );
 320         top.add( category );
 321         addSubelementEditable( category,
 322                                NodePanel.LIT_REFERENCE_DESC,
 323                                ref.getDescription(),
 324                                PHYLOXML_TAG.LIT_REFERENCE_DESC );
 325         addSubelementEditable( category, NodePanel.LIT_REFERENCE_DOI, ref.getDoi(), PHYLOXML_TAG.LIT_REFERENCE_DOI );
 326     }
 327
 328     private void addSequence( final DefaultMutableTreeNode top, Sequence seq, final String name ) {
 329         if ( seq == null ) {
 330             seq = new Sequence();
 331         }
 332         final DefaultMutableTreeNode category = new DefaultMutableTreeNode( name );
 333         top.add( category );
 334         Accession acc = seq.getAccession();
 335         if ( acc == null ) {
 336             acc = new Accession( "", "" );
 337         }
 338         addSubelementEditable( category, NodePanel.SEQ_NAME, seq.getName(), PHYLOXML_TAG.SEQ_NAME );
 339         addSubelementEditable( category, NodePanel.SEQ_SYMBOL, seq.getSymbol(), PHYLOXML_TAG.SEQ_SYMBOL );
 340         addSubelementEditable( category,
 341                                NodePanel.SEQ_ACCESSION,
 342                                acc.getValue(),
 343                                PHYLOXML_TAG.SEQ_ACC_VALUE,
 344                                "Source",
 345                                acc.getSource(),
 346                                PHYLOXML_TAG.SEQ_ACC_SOURCE );
 347         addSubelementEditable( category, NodePanel.SEQ_LOCATION, seq.getLocation(), PHYLOXML_TAG.SEQ_LOCATION );
 348         addSubelementEditable( category, NodePanel.SEQ_TYPE, seq.getType(), PHYLOXML_TAG.SEQ_TYPE );
 349         addSubelementEditable( category, NodePanel.SEQ_MOL_SEQ, seq.getMolecularSequence(), PHYLOXML_TAG.SEQ_MOL_SEQ );
 350         int uri_counter = 0;
 351         if ( seq.getUris() != null ) {
 352             for( final Uri uri : seq.getUris() ) {
 353                 if ( uri != null ) {
 354                     addSubelementEditable( category, NodePanel.SEQ_URI + " [" + uri_counter + "]", uri.getValue()
 355                             .toString(), PHYLOXML_TAG.SEQ_URI, uri_counter++ );
 356                 }
 357             }
 358         }
 359         addSubelementEditable( category,
 360                                NodePanel.SEQ_URI + " [" + uri_counter + "]",
 361                                "",
 362                                PHYLOXML_TAG.SEQ_URI,
 363                                uri_counter );
 364         //  addAnnotations( top, seq.getAnnotations(), category );
 365     }
 366
 367     private void addSubelementEditable( final DefaultMutableTreeNode node,
 368                                         final String name,
 369                                         final String value,
 370                                         final PHYLOXML_TAG phyloxml_tag ) {
 371         addSubelementEditable( node, name, value, phyloxml_tag, 0 );
 372     }
 373
 374     private void addSubelementEditable( final DefaultMutableTreeNode node,
 375                                         final String name,
 376                                         final String value,
 377                                         final PHYLOXML_TAG phyloxml_tag,
 378                                         final int number ) {
 379         String my_value = value;
 380         if ( ForesterUtil.isEmpty( my_value ) ) {
 381             my_value = "";
 382         }
 383         final DefaultMutableTreeNode name_node = new DefaultMutableTreeNode( name );
 384         final DefaultMutableTreeNode value_node = new DefaultMutableTreeNode( my_value );
 385         name_node.add( value_node );
 386         node.add( name_node );
 387         addMapping( name_node, new TagNumber( phyloxml_tag, number ) );
 388     }
 389
 390     private void addSubelementEditable( final DefaultMutableTreeNode node,
 391                                         final String name,
 392                                         final String value,
 393                                         final PHYLOXML_TAG phyloxml_value_tag,
 394                                         final String source_name,
 395                                         final String source_value,
 396                                         final PHYLOXML_TAG phyloxml_source_tag ) {
 397         addSubelementEditable( node, name, value, phyloxml_value_tag, source_name, source_value, phyloxml_source_tag, 0 );
 398     }
 399
 400     private void addSubelementEditable( final DefaultMutableTreeNode node,
 401                                         final String name,
 402                                         final String value,
 403                                         final PHYLOXML_TAG phyloxml_value_tag,
 404                                         final String source_name,
 405                                         final String source_value,
 406                                         final PHYLOXML_TAG phyloxml_source_tag,
 407                                         final int number ) {
 408         String my_value = value;
 409         if ( ForesterUtil.isEmpty( my_value ) ) {
 410             my_value = "";
 411         }
 412         String my_source_value = source_value;
 413         if ( ForesterUtil.isEmpty( my_source_value ) ) {
 414             my_source_value = "";
 415         }
 416         final DefaultMutableTreeNode name_node = new DefaultMutableTreeNode( name );
 417         final DefaultMutableTreeNode source_name_node = new DefaultMutableTreeNode( source_name );
 418         final DefaultMutableTreeNode source_value_node = new DefaultMutableTreeNode( my_source_value );
 419         final DefaultMutableTreeNode value_node = new DefaultMutableTreeNode( my_value );
 420         name_node.add( source_name_node );
 421         source_name_node.add( source_value_node );
 422         name_node.add( value_node );
 423         node.add( name_node );
 424         addMapping( name_node, new TagNumber( phyloxml_value_tag, number ) );
 425         addMapping( source_name_node, new TagNumber( phyloxml_source_tag, number ) );
 426     }
 427
 428     private void addTaxonomy( final DefaultMutableTreeNode top, Taxonomy tax, final String name ) {
 429         if ( tax == null ) {
 430             tax = new Taxonomy();
 431         }
 432         final DefaultMutableTreeNode category = new DefaultMutableTreeNode( name );
 433         top.add( category );
 434         Identifier id = tax.getIdentifier();
 435         if ( id == null ) {
 436             id = new Identifier();
 437         }
 438         addSubelementEditable( category,
 439                                NodePanel.TAXONOMY_IDENTIFIER,
 440                                id.getValue(),
 441                                PHYLOXML_TAG.TAXONOMY_ID_VALUE,
 442                                "Provider",
 443                                id.getProvider(),
 444                                PHYLOXML_TAG.TAXONOMY_ID_PROVIDER );
 445         addSubelementEditable( category, NodePanel.TAXONOMY_CODE, tax.getTaxonomyCode(), PHYLOXML_TAG.TAXONOMY_CODE );
 446         addSubelementEditable( category,
 447                                NodePanel.TAXONOMY_SCIENTIFIC_NAME,
 448                                tax.getScientificName(),
 449                                PHYLOXML_TAG.TAXONOMY_SCIENTIFIC_NAME );
 450         addSubelementEditable( category,
 451                                NodePanel.TAXONOMY_AUTHORITY,
 452                                tax.getAuthority(),
 453                                PHYLOXML_TAG.TAXONOMY_AUTHORITY );
 454         addSubelementEditable( category,
 455                                NodePanel.TAXONOMY_COMMON_NAME,
 456                                tax.getCommonName(),
 457                                PHYLOXML_TAG.TAXONOMY_COMMON_NAME );
 458         for( int i = tax.getSynonyms().size() - 1; i >= 0; i-- ) {
 459             if ( ForesterUtil.isEmpty( tax.getSynonyms().get( i ) ) ) {
 460                 tax.getSynonyms().remove( i );
 461             }
 462         }
 463         int syn_counter = 0;
 464         for( final String syn : tax.getSynonyms() ) {
 465             addSubelementEditable( category,
 466                                    NodePanel.TAXONOMY_SYNONYM + " [" + syn_counter + "]",
 467                                    syn,
 468                                    PHYLOXML_TAG.TAXONOMY_SYNONYM,
 469                                    syn_counter++ );
 470         }
 471         addSubelementEditable( category,
 472                                NodePanel.TAXONOMY_SYNONYM + " [" + syn_counter + "]",
 473                                "",
 474                                PHYLOXML_TAG.TAXONOMY_SYNONYM,
 475                                syn_counter );
 476         addSubelementEditable( category, NodePanel.TAXONOMY_RANK, tax.getRank(), PHYLOXML_TAG.TAXONOMY_RANK );
 477         int uri_counter = 0;
 478         if ( tax.getUris() != null ) {
 479             for( final Uri uri : tax.getUris() ) {
 480                 if ( uri != null ) {
 481                     addSubelementEditable( category, NodePanel.TAXONOMY_URI + " [" + uri_counter + "]", uri.getValue()
 482                             .toString(), PHYLOXML_TAG.TAXONOMY_URI, uri_counter++ );
 483                 }
 484             }
 485         }
 486         addSubelementEditable( category,
 487                                NodePanel.TAXONOMY_URI + " [" + uri_counter + "]",
 488                                "",
 489                                PHYLOXML_TAG.TAXONOMY_URI,
 490                                uri_counter );
 491     }
 492
 493     private void collapsePath( final String name ) {
 494         final TreePath tp = getJTree().getNextMatch( name, 0, Position.Bias.Forward );
 495         if ( tp != null ) {
 496             getJTree().collapsePath( tp );
 497         }
 498     }
 499
 500     private void createNodes( final DefaultMutableTreeNode top, final PhylogenyNode phylogeny_node ) {
 501         if ( !phylogeny_node.getNodeData().isHasTaxonomy() ) {
 502             phylogeny_node.getNodeData().addTaxonomy( new Taxonomy() );
 503         }
 504         if ( !phylogeny_node.getNodeData().isHasSequence() ) {
 505             phylogeny_node.getNodeData().addSequence( new Sequence() );
 506         }
 507         if ( !phylogeny_node.getNodeData().isHasDistribution() ) {
 508             phylogeny_node.getNodeData().addDistribution( new Distribution( "" ) );
 509         }
 510         if ( !phylogeny_node.getNodeData().isHasReference() ) {
 511             phylogeny_node.getNodeData().addReference( new Reference( "" ) );
 512         }
 513         addBasics( top, phylogeny_node, NodePanel.BASIC );
 514         addTaxonomy( top, phylogeny_node.getNodeData().getTaxonomy(), NodePanel.TAXONOMY );
 515         addSequence( top, phylogeny_node.getNodeData().getSequence(), NodePanel.SEQUENCE );
 516         if ( !phylogeny_node.isExternal() ) {
 517             addEvents( top, phylogeny_node.getNodeData().getEvent(), NodePanel.EVENTS );
 518         }
 519         addDate( top, phylogeny_node.getNodeData().getDate(), NodePanel.DATE );
 520         addDistribution( top, phylogeny_node.getNodeData().getDistribution(), NodePanel.DISTRIBUTION );
 521         addReference( top, phylogeny_node.getNodeData().getReference(), NodePanel.LIT_REFERENCE );
 522         //  addProperties( top, phylogeny_node.getNodeData().getProperties(), "Properties" );
 523     }
 524
 525     private void formatError( final DefaultMutableTreeNode mtn, final PhyloXmlDataFormatException e ) {
 526         JOptionPane.showMessageDialog( this, e.getMessage(), "Format error", JOptionPane.ERROR_MESSAGE );
 527         mtn.setUserObject( "" );
 528         getJTree().repaint();
 529     }
 530
 531     private JTree getJTree() {
 532         return _tree;
 533     }
 534
 535     private Map<DefaultMutableTreeNode, TagNumber> getMap() {
 536         return _map;
 537     }
 538
 539     private TagNumber getMapping( final DefaultMutableTreeNode mtn ) {
 540         return getMap().get( mtn );
 541     }
 542
 543     PhylogenyNode getMyNode() {
 544         return _my_node;
 545     }
 546
 547     private DefaultMutableTreeNode getSelectedTreeNode() {
 548         final TreePath selectionPath = getJTree().getSelectionPath();
 549         if ( selectionPath != null ) {
 550             final Object[] path = selectionPath.getPath();
 551             if ( path.length > 0 ) {
 552                 return ( DefaultMutableTreeNode ) path[ path.length - 1 ]; // Last node
 553             }
 554         }
 555         return null;
 556     }
 557
 558     private TreePanel getTreePanel() {
 559         return _tree_panel;
 560     }
 561
 562     private void keyEvent( final KeyEvent e ) {
 563         if ( e.getKeyCode() == KeyEvent.VK_ENTER ) {
 564             writeBack( getSelectedTreeNode() );
 565         }
 566     }
 567
 568     private List<Point> obtainPoints() {
 569         ForesterUtil.ensurePresenceOfDistribution( getMyNode() );
 570         Distribution d = getMyNode().getNodeData().getDistribution();
 571         if ( d.getPoints() == null ) {
 572             d = new Distribution( d.getDesc(), new ArrayList<Point>(), d.getPolygons() );
 573             getMyNode().getNodeData().setDistribution( d );
 574         }
 575         final List<Point> ps = d.getPoints();
 576         if ( ps.isEmpty() ) {
 577             ps.add( new Point() );
 578         }
 579         else if ( ps.get( 0 ) == null ) {
 580             ps.set( 0, new Point() );
 581         }
 582         return ps;
 583     }
 584
 585     private BigDecimal parseBigDecimal( final DefaultMutableTreeNode mtn, final String value ) {
 586         if ( ForesterUtil.isEmpty( value ) ) {
 587             return new BigDecimal( 0 );
 588         }
 589         BigDecimal i = null;
 590         try {
 591             i = new BigDecimal( value );
 592         }
 593         catch ( final NumberFormatException e ) {
 594             JOptionPane.showMessageDialog( this, "illegal value: " + value, "Error", JOptionPane.ERROR_MESSAGE );
 595             mtn.setUserObject( "" );
 596         }
 597         return i;
 598     }
 599
 600     private int parsePositiveInt( final DefaultMutableTreeNode mtn, final String value ) {
 601         if ( ForesterUtil.isEmpty( value ) ) {
 602             return 0;
 603         }
 604         int i = -1;
 605         try {
 606             i = ForesterUtil.parseInt( value );
 607         }
 608         catch ( final ParseException e ) {
 609             JOptionPane.showMessageDialog( this, "illegal value: " + value, "Error", JOptionPane.ERROR_MESSAGE );
 610             mtn.setUserObject( "" );
 611         }
 612         if ( i < 0 ) {
 613             JOptionPane.showMessageDialog( this, "illegal value: " + value, "Error", JOptionPane.ERROR_MESSAGE );
 614             mtn.setUserObject( "" );
 615         }
 616         return i;
 617     }
 618
 619     void writeAll() {
 620         for( int i = 0; i < getJTree().getRowCount(); i++ ) {
 621             final TreePath p = getJTree().getPathForRow( i );
 622             writeBack( ( DefaultMutableTreeNode ) p.getLastPathComponent() );
 623         }
 624     }
 625
 626     private void writeBack( final DefaultMutableTreeNode mtn ) {
 627         if ( !getMap().containsKey( mtn ) ) {
 628             final DefaultMutableTreeNode parent = ( DefaultMutableTreeNode ) mtn.getParent();
 629             if ( getMap().containsKey( parent ) ) {
 630                 writeBack( mtn, getMapping( parent ) );
 631             }
 632         }
 633     }
 634
 635     private void writeBack( final DefaultMutableTreeNode mtn, final TagNumber tag_number ) {
 636         if ( tag_number == null ) {
 637             return;
 638         }
 639         String value = mtn.toString();
 640         if ( value == null ) {
 641             value = "";
 642         }
 643         value = value.replaceAll( "\\s+", " " );
 644         value = value.trim();
 645         mtn.setUserObject( value );
 646         getJTree().repaint();
 647         final PHYLOXML_TAG tag = tag_number.getTag();
 648         final int number = tag_number.getNumber();
 649         switch ( tag ) {
 650             case NODE_NAME:
 651                 getMyNode().setName( value );
 652                 break;
 653             case NODE_BRANCH_LENGTH:
 654                 if ( ForesterUtil.isEmpty( value ) ) {
 655                     getMyNode().setDistanceToParent( PhylogenyDataUtil.BRANCH_LENGTH_DEFAULT );
 656                 }
 657                 else {
 658                     try {
 659                         getMyNode().setDistanceToParent( ForesterUtil.parseDouble( value ) );
 660                     }
 661                     catch ( final ParseException e ) {
 662                         JOptionPane.showMessageDialog( this,
 663                                                        "failed to parse branch length from: " + value,
 664                                                        "Error",
 665                                                        JOptionPane.ERROR_MESSAGE );
 666                         mtn.setUserObject( "" );
 667                     }
 668                 }
 669                 break;
 670             case NODE_BRANCH_WIDTH:
 671                 if ( ForesterUtil.isEmpty( value ) || value.equals( "1" ) ) {
 672                     if ( getMyNode().getBranchData().getBranchWidth() != null ) {
 673                         getMyNode().getBranchData().setBranchWidth( new BranchWidth() );
 674                     }
 675                 }
 676                 else {
 677                     try {
 678                         final double bw = ForesterUtil.parseDouble( value );
 679                         if ( bw >= 0 ) {
 680                             getMyNode().getBranchData().setBranchWidth( new BranchWidth( bw ) );
 681                         }
 682                     }
 683                     catch ( final ParseException e ) {
 684                         JOptionPane.showMessageDialog( this,
 685                                                        "failed to parse branch width from: " + value,
 686                                                        "Error",
 687                                                        JOptionPane.ERROR_MESSAGE );
 688                         mtn.setUserObject( "" );
 689                     }
 690                 }
 691                 break;
 692             case CONFIDENCE_VALUE:
 693                 double confidence = Confidence.CONFIDENCE_DEFAULT_VALUE;
 694                 if ( !ForesterUtil.isEmpty( value ) ) {
 695                     try {
 696                         confidence = ForesterUtil.parseDouble( value );
 697                     }
 698                     catch ( final ParseException e ) {
 699                         JOptionPane.showMessageDialog( this,
 700                                                        "failed to parse confidence value from: " + value,
 701                                                        "Error",
 702                                                        JOptionPane.ERROR_MESSAGE );
 703                         mtn.setUserObject( "" );
 704                         break;
 705                     }
 706                 }
 707                 if ( getMyNode().getBranchData().getConfidences().size() < number ) {
 708                     throw new FailedConditionCheckException();
 709                 }
 710                 else if ( getMyNode().getBranchData().getConfidences().size() == number ) {
 711                     if ( confidence >= 0 ) {
 712                         getMyNode().getBranchData().getConfidences().add( new Confidence( confidence, "unknown" ) );
 713                     }
 714                 }
 715                 else {
 716                     final String type = getMyNode().getBranchData().getConfidences().get( number ).getType();
 717                     final double sd = getMyNode().getBranchData().getConfidences().get( number ).getStandardDeviation();
 718                     getMyNode().getBranchData().getConfidences().set( number, new Confidence( confidence, type, sd ) );
 719                 }
 720                 break;
 721             case CONFIDENCE_TYPE:
 722                 if ( getMyNode().getBranchData().getConfidences().size() < number ) {
 723                     throw new FailedConditionCheckException();
 724                 }
 725                 else if ( getMyNode().getBranchData().getConfidences().size() == number ) {
 726                     if ( !ForesterUtil.isEmpty( value ) ) {
 727                         getMyNode().getBranchData().getConfidences().add( new Confidence( 0, value ) );
 728                     }
 729                 }
 730                 else {
 731                     final double v = getMyNode().getBranchData().getConfidences().get( number ).getValue();
 732                     final double sd = getMyNode().getBranchData().getConfidences().get( number ).getStandardDeviation();
 733                     getMyNode().getBranchData().getConfidences().set( number, new Confidence( v, value, sd ) );
 734                 }
 735                 break;
 736             case TAXONOMY_CODE:
 737                 ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 738                 try {
 739                     getMyNode().getNodeData().getTaxonomy().setTaxonomyCode( value );
 740                 }
 741                 catch ( final PhyloXmlDataFormatException e ) {
 742                     formatError( mtn, e );
 743                     break;
 744                 }
 745                 break;
 746             case TAXONOMY_SCIENTIFIC_NAME:
 747                 ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 748                 getMyNode().getNodeData().getTaxonomy().setScientificName( value );
 749                 break;
 750             case TAXONOMY_COMMON_NAME:
 751                 ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 752                 getMyNode().getNodeData().getTaxonomy().setCommonName( value );
 753                 break;
 754             case TAXONOMY_RANK:
 755                 ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 756                 try {
 757                     getMyNode().getNodeData().getTaxonomy().setRank( value.toLowerCase() );
 758                 }
 759                 catch ( final PhyloXmlDataFormatException e ) {
 760                     formatError( mtn, e );
 761                     break;
 762                 }
 763                 break;
 764             case TAXONOMY_AUTHORITY:
 765                 ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 766                 getMyNode().getNodeData().getTaxonomy().setAuthority( value );
 767                 break;
 768             case TAXONOMY_URI: {
 769                 Uri uri = null;
 770                 if ( !ForesterUtil.isEmpty( value ) ) {
 771                     try {
 772                         uri = new Uri( new URL( value ).toURI() );
 773                     }
 774                     catch ( final Exception e ) {
 775                         JOptionPane.showMessageDialog( this,
 776                                                        "failed to parse URL from: " + value,
 777                                                        "Error",
 778                                                        JOptionPane.ERROR_MESSAGE );
 779                         mtn.setUserObject( "" );
 780                     }
 781                 }
 782                 if ( uri != null ) {
 783                     ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 784                 }
 785                 addUri( mtn, uri, number, getMyNode().getNodeData().getTaxonomy() );
 786                 break;
 787             }
 788             case TAXONOMY_SYNONYM:
 789                 if ( getMyNode().getNodeData().getTaxonomy().getSynonyms().size() < number ) {
 790                     throw new FailedConditionCheckException();
 791                 }
 792                 else if ( getMyNode().getNodeData().getTaxonomy().getSynonyms().size() == number ) {
 793                     if ( !ForesterUtil.isEmpty( value ) ) {
 794                         ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 795                         getMyNode().getNodeData().getTaxonomy().getSynonyms().add( value );
 796                     }
 797                 }
 798                 else {
 799                     getMyNode().getNodeData().getTaxonomy().getSynonyms().set( number, value );
 800                 }
 801                 break;
 802             case TAXONOMY_ID_VALUE:
 803                 ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 804                 if ( getMyNode().getNodeData().getTaxonomy().getIdentifier() == null ) {
 805                     getMyNode().getNodeData().getTaxonomy().setIdentifier( new Identifier( value ) );
 806                 }
 807                 else {
 808                     final String provider = getMyNode().getNodeData().getTaxonomy().getIdentifier().getProvider();
 809                     getMyNode().getNodeData().getTaxonomy().setIdentifier( new Identifier( value, provider ) );
 810                 }
 811                 break;
 812             case TAXONOMY_ID_PROVIDER:
 813                 ForesterUtil.ensurePresenceOfTaxonomy( getMyNode() );
 814                 if ( getMyNode().getNodeData().getTaxonomy().getIdentifier() == null ) {
 815                     getMyNode().getNodeData().getTaxonomy().setIdentifier( new Identifier( "", value ) );
 816                 }
 817                 else {
 818                     final String v = getMyNode().getNodeData().getTaxonomy().getIdentifier().getValue();
 819                     getMyNode().getNodeData().getTaxonomy().setIdentifier( new Identifier( v, value ) );
 820                 }
 821                 break;
 822             case SEQ_LOCATION:
 823                 ForesterUtil.ensurePresenceOfSequence( getMyNode() );
 824                 getMyNode().getNodeData().getSequence().setLocation( value );
 825                 break;
 826             case SEQ_MOL_SEQ:
 827                 ForesterUtil.ensurePresenceOfSequence( getMyNode() );
 828                 getMyNode().getNodeData().getSequence().setMolecularSequence( value.replaceAll( "[^a-zA-Z-]", "" ) );
 829                 break;
 830             case SEQ_NAME:
 831                 ForesterUtil.ensurePresenceOfSequence( getMyNode() );
 832                 getMyNode().getNodeData().getSequence().setName( value );
 833                 break;
 834             case SEQ_SYMBOL:
 835                 ForesterUtil.ensurePresenceOfSequence( getMyNode() );
 836                 try {
 837                     getMyNode().getNodeData().getSequence().setSymbol( value );
 838                 }
 839                 catch ( final PhyloXmlDataFormatException e ) {
 840                     formatError( mtn, e );
 841                     break;
 842                 }
 843                 break;
 844             case SEQ_TYPE:
 845                 ForesterUtil.ensurePresenceOfSequence( getMyNode() );
 846                 try {
 847                     getMyNode().getNodeData().getSequence().setType( value.toLowerCase() );
 848                 }
 849                 catch ( final PhyloXmlDataFormatException e ) {
 850                     formatError( mtn, e );
 851                     break;
 852                 }
 853                 break;
 854             case SEQ_ACC_SOURCE:
 855                 ForesterUtil.ensurePresenceOfSequence( getMyNode() );
 856                 if ( getMyNode().getNodeData().getSequence().getAccession() == null ) {
 857                     getMyNode().getNodeData().getSequence().setAccession( new Accession( "", value ) );
 858                 }
 859                 else {
 860                     final String v = getMyNode().getNodeData().getSequence().getAccession().getValue();
 861                     getMyNode().getNodeData().getSequence().setAccession( new Accession( v, value ) );
 862                 }
 863                 break;
 864             case SEQ_ACC_VALUE:
 865                 ForesterUtil.ensurePresenceOfSequence( getMyNode() );
 866                 if ( getMyNode().getNodeData().getSequence().getAccession() == null ) {
 867                     getMyNode().getNodeData().getSequence().setAccession( new Accession( value, "" ) );
 868                 }
 869                 else {
 870                     final String source = getMyNode().getNodeData().getSequence().getAccession().getSource();
 871                     getMyNode().getNodeData().getSequence().setAccession( new Accession( value, source ) );
 872                 }
 873                 break;
 874             case SEQ_URI: {
 875                 Uri uri = null;
 876                 if ( !ForesterUtil.isEmpty( value ) ) {
 877                     try {
 878                         uri = new Uri( new URL( value ).toURI() );
 879                     }
 880                     catch ( final Exception e ) {
 881                         JOptionPane.showMessageDialog( this,
 882                                                        "failed to parse URL from: " + value,
 883                                                        "Error",
 884                                                        JOptionPane.ERROR_MESSAGE );
 885                         mtn.setUserObject( "" );
 886                     }
 887                 }
 888                 if ( uri != null ) {
 889                     ForesterUtil.ensurePresenceOfSequence( getMyNode() );
 890                 }
 891                 addUri( mtn, uri, number, getMyNode().getNodeData().getSequence() );
 892                 break;
 893             }
 894             case LIT_REFERENCE_DESC:
 895                 if ( !getMyNode().getNodeData().isHasReference() ) {
 896                     getMyNode().getNodeData().setReference( new Reference( "" ) );
 897                 }
 898                 getMyNode().getNodeData().getReference().setValue( value );
 899                 break;
 900             case LIT_REFERENCE_DOI:
 901                 if ( !getMyNode().getNodeData().isHasReference() ) {
 902                     getMyNode().getNodeData().setReference( new Reference( "" ) );
 903                 }
 904                 try {
 905                     getMyNode().getNodeData().getReference().setDoi( value );
 906                 }
 907                 catch ( final PhyloXmlDataFormatException e ) {
 908                     formatError( mtn, e );
 909                     break;
 910                 }
 911                 break;
 912             case EVENTS_DUPLICATIONS:
 913                 if ( !getMyNode().getNodeData().isHasEvent() ) {
 914                     getMyNode().getNodeData().setEvent( new Event() );
 915                 }
 916                 getMyNode().getNodeData().getEvent().setDuplications( parsePositiveInt( mtn, value ) );
 917                 break;
 918             case EVENTS_SPECIATIONS:
 919                 if ( !getMyNode().getNodeData().isHasEvent() ) {
 920                     getMyNode().getNodeData().setEvent( new Event() );
 921                 }
 922                 getMyNode().getNodeData().getEvent().setSpeciations( parsePositiveInt( mtn, value ) );
 923                 break;
 924             case EVENTS_GENE_LOSSES:
 925                 if ( !getMyNode().getNodeData().isHasEvent() ) {
 926                     getMyNode().getNodeData().setEvent( new Event() );
 927                 }
 928                 getMyNode().getNodeData().getEvent().setGeneLosses( parsePositiveInt( mtn, value ) );
 929                 break;
 930             case DATE_DESCRIPTION:
 931                 ForesterUtil.ensurePresenceOfDate( getMyNode() );
 932                 getMyNode().getNodeData().getDate().setDesc( value );
 933                 break;
 934             case DATE_MAX:
 935                 ForesterUtil.ensurePresenceOfDate( getMyNode() );
 936                 getMyNode().getNodeData().getDate().setMax( parseBigDecimal( mtn, value ) );
 937                 break;
 938             case DATE_MIN:
 939                 ForesterUtil.ensurePresenceOfDate( getMyNode() );
 940                 getMyNode().getNodeData().getDate().setMin( parseBigDecimal( mtn, value ) );
 941                 break;
 942             case DATE_UNIT:
 943                 ForesterUtil.ensurePresenceOfDate( getMyNode() );
 944                 getMyNode().getNodeData().getDate().setUnit( value );
 945                 break;
 946             case DATE_VALUE:
 947                 ForesterUtil.ensurePresenceOfDate( getMyNode() );
 948                 getMyNode().getNodeData().getDate().setValue( parseBigDecimal( mtn, value ) );
 949                 break;
 950             case DIST_ALT: {
 951                 final BigDecimal new_value = parseBigDecimal( mtn, value );
 952                 if ( new_value != null ) {
 953                     final List<Point> ps = obtainPoints();
 954                     final Point p = ps.get( 0 );
 955                     final Point p_new = new Point( p.getGeodeticDatum(),
 956                                                    p.getLatitude(),
 957                                                    p.getLongitude(),
 958                                                    new_value,
 959                                                    ForesterUtil.isEmpty( p.getAltiudeUnit() ) ? "?"
 960                                                            : p.getAltiudeUnit() );
 961                     ps.set( 0, p_new );
 962                 }
 963                 break;
 964             }
 965             case DIST_DESC: {
 966                 ForesterUtil.ensurePresenceOfDistribution( getMyNode() );
 967                 final Distribution d = getMyNode().getNodeData().getDistribution();
 968                 getMyNode().getNodeData().setDistribution( new Distribution( value, d.getPoints(), d.getPolygons() ) );
 969                 break;
 970             }
 971             case DIST_GEODETIC: {
 972                 if ( !ForesterUtil.isEmpty( value ) ) {
 973                     final List<Point> ps = obtainPoints();
 974                     final Point p = ps.get( 0 );
 975                     final Point p_new = new Point( value,
 976                                                    p.getLatitude(),
 977                                                    p.getLongitude(),
 978                                                    p.getAltitude(),
 979                                                    p.getAltiudeUnit() );
 980                     ps.set( 0, p_new );
 981                 }
 982                 break;
 983             }
 984             case DIST_ALT_UNIT: {
 985                 if ( !ForesterUtil.isEmpty( value ) ) {
 986                     final List<Point> ps = obtainPoints();
 987                     final Point p = ps.get( 0 );
 988                     final Point p_new = new Point( p.getGeodeticDatum(),
 989                                                    p.getLatitude(),
 990                                                    p.getLongitude(),
 991                                                    p.getAltitude(),
 992                                                    value );
 993                     ps.set( 0, p_new );
 994                 }
 995                 break;
 996             }
 997             case DIST_LAT: {
 998                 final BigDecimal new_value = parseBigDecimal( mtn, value );
 999                 if ( new_value != null ) {
1000                     final List<Point> ps = obtainPoints();
1001                     final Point p = ps.get( 0 );
1002                     final Point p_new = new Point( p.getGeodeticDatum(),
1003                                                    new_value,
1004                                                    p.getLongitude(),
1005                                                    p.getAltitude(),
1006                                                    p.getAltiudeUnit() );
1007                     ps.set( 0, p_new );
1008                 }
1009                 break;
1010             }
1011             case DIST_LONG: {
1012                 final BigDecimal new_value = parseBigDecimal( mtn, value );
1013                 if ( new_value != null ) {
1014                     final List<Point> ps = obtainPoints();
1015                     final Point p = ps.get( 0 );
1016                     final Point p_new = new Point( p.getGeodeticDatum(),
1017                                                    p.getLatitude(),
1018                                                    new_value,
1019                                                    p.getAltitude(),
1020                                                    p.getAltiudeUnit() );
1021                     ps.set( 0, p_new );
1022                 }
1023                 break;
1024             }
1025             default:
1026                 throw new IllegalArgumentException( "unknown: " + tag );
1027         }
1028         getJTree().repaint();
1029         getTreePanel().setEdited( true );
1030         getTreePanel().repaint();
1031     }
1032
1033     private void addUri( final DefaultMutableTreeNode mtn, final Uri uri, final int number, final MultipleUris mu ) {
1034         if ( uri != null ) {
1035             if ( mu.getUris() == null ) {
1036                 mu.setUris( new ArrayList<Uri>() );
1037             }
1038         }
1039         if ( ( uri != null ) && ( mu.getUris() == null ) ) {
1040             mu.setUris( new ArrayList<Uri>() );
1041         }
1042         if ( ( uri != null ) && ( mu.getUris().size() == number ) ) {
1043             mu.getUris().add( uri );
1044         }
1045         if ( ( mu.getUris() != null ) && ( mu.getUris().size() != number ) ) {
1046             mu.getUris().set( number, uri );
1047         }
1048         final ImageLoader il = new ImageLoader( getTreePanel() );
1049         new Thread( il ).start();
1050     }
1051
1052     private enum PHYLOXML_TAG {
1053         NODE_NAME,
1054         NODE_BRANCH_LENGTH,
1055         NODE_BRANCH_WIDTH,
1056         TAXONOMY_CODE,
1057         TAXONOMY_SCIENTIFIC_NAME,
1058         TAXONOMY_AUTHORITY,
1059         TAXONOMY_COMMON_NAME,
1060         TAXONOMY_SYNONYM,
1061         TAXONOMY_RANK,
1062         TAXONOMY_URI,
1063         SEQ_SYMBOL,
1064         SEQ_NAME,
1065         SEQ_LOCATION,
1066         SEQ_TYPE,
1067         SEQ_MOL_SEQ,
1068         SEQ_URI,
1069         DATE_DESCRIPTION,
1070         DATE_VALUE,
1071         DATE_MIN,
1072         DATE_MAX,
1073         DATE_UNIT,
1074         TAXONOMY_ID_VALUE,
1075         TAXONOMY_ID_PROVIDER,
1076         SEQ_ACC_VALUE,
1077         SEQ_ACC_SOURCE,
1078         CONFIDENCE_VALUE,
1079         CONFIDENCE_TYPE,
1080         LIT_REFERENCE_DESC,
1081         LIT_REFERENCE_DOI,
1082         EVENTS_DUPLICATIONS,
1083         EVENTS_SPECIATIONS,
1084         EVENTS_GENE_LOSSES,
1085         DIST_DESC,
1086         DIST_GEODETIC,
1087         DIST_LAT,
1088         DIST_LONG,
1089         DIST_ALT,
1090         DIST_ALT_UNIT
1091     }
1092
1093     private class TagNumber {
1094
1095         final private PHYLOXML_TAG _tag;
1096         final private int          _number;
1097
1098         TagNumber( final PHYLOXML_TAG tag, final int number ) {
1099             _tag = tag;
1100             _number = number;
1101         }
1102
1103         int getNumber() {
1104             return _number;
1105         }
1106
1107         PHYLOXML_TAG getTag() {
1108             return _tag;
1109         }
1110
1111         @Override
1112         public String toString() {
1113             return getTag() + "_" + getNumber();
1114         }
1115     }
1116 }