src/jalview/io/VamsasDatastore.java

   1 /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer\r
   3  * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4  *\r
   5  * This program is free software; you can redistribute it and/or\r
   6  * modify it under the terms of the GNU General Public License\r
   7  * as published by the Free Software Foundation; either version 2\r
   8  * of the License, or (at your option) any later version.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  * You should have received a copy of the GNU General Public License\r
  16  * along with this program; if not, write to the Free Software\r
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18  */\r
  19 \r
  20 package jalview.io;\r
  21 \r
  22 import org.vamsas.client.Vobject;\r
  23 import org.vamsas.client.VorbaId;\r
  24 import org.vamsas.objects.core.*;\r
  25 import org.vamsas.objects.utils.DocumentStuff;\r
  26 import org.vamsas.test.simpleclient.ClientDoc;\r
  27 \r
  28 import jalview.bin.Cache;\r
  29 import jalview.datamodel.SequenceI;\r
  30 import jalview.gui.*;\r
  31 import java.io.*;\r
  32 import java.util.HashMap;\r
  33 import java.util.HashSet;\r
  34 import java.util.Hashtable;\r
  35 import java.util.IdentityHashMap;\r
  36 import java.util.jar.*;\r
  37 import org.exolab.castor.xml.*;\r
  38 import org.exolab.castor.mapping.Mapping;\r
  39 \r
  40 /*\r
  41 \r
  42  static {\r
  43  org.exolab.castor.util.LocalConfiguration.getInstance().getProperties().setProperty(\r
  44  "org.exolab.castor.serializer", "org.apache.xml.serialize.XMLSerilazizer");\r
  45  }\r
  46 \r
  47  */\r
  48 \r
  49 public class VamsasDatastore\r
  50 {\r
  51         Entry provEntry=null;\r
  52         AlignViewport av;\r
  53         org.exolab.castor.types.Date date\r
  54         = new org.exolab.castor.types.Date(new java.util.Date());\r
  55         ClientDoc cdoc;\r
  56         Hashtable vobj2jv;\r
  57         IdentityHashMap jv2vobj;\r
  58         public VamsasDatastore(ClientDoc cdoc, Hashtable vobj2jv, IdentityHashMap jv2vobj, Entry provEntry) {\r
  59                 \r
  60                 this.cdoc = cdoc;\r
  61                 this.vobj2jv = vobj2jv;\r
  62                 this.jv2vobj = jv2vobj;\r
  63                 this.provEntry = provEntry;\r
  64         }\r
  65         \r
  66         /* public void storeJalview(String file, AlignFrame af)\r
  67         {\r
  68           try\r
  69           {\r
  70             // 1. Load the mapping information from the file\r
  71             Mapping map = new Mapping(getClass().getClassLoader());\r
  72             java.net.URL url = getClass().getResource("/jalview_mapping.xml");\r
  73             map.loadMapping(url);\r
  74 \r
  75             // 2. Unmarshal the data\r
  76             // Unmarshaller unmar = new Unmarshaller();\r
  77             //unmar.setIgnoreExtraElements(true);\r
  78             //unmar.setMapping(map);\r
  79             // uni = (UniprotFile) unmar.unmarshal(new FileReader(file));\r
  80 \r
  81             // 3. marshal the data with the total price back and print the XML in the console\r
  82               Marshaller marshaller = new Marshaller( new FileWriter(file) );\r
  83 \r
  84              marshaller.setMapping(map);\r
  85              marshaller.marshal(af);\r
  86           }\r
  87           catch (Exception e)\r
  88           {\r
  89             e.printStackTrace();\r
  90           }\r
  91         }\r
  92 \r
  93 \r
  94          */\r
  95         \r
  96         protected Vobject getjv2vObj(Object jvobj) {\r
  97                 if (jv2vobj.containsKey(jvobj))\r
  98                         return cdoc.getObject(((VorbaId)jv2vobj.get(jvobj)));\r
  99                 return null;\r
 100         }\r
 101         \r
 102         protected Object getvObj2jv(org.vamsas.client.Vobject vobj) {\r
 103                 VorbaId id = vobj.getVorbaId();\r
 104                 if (id==null) {\r
 105                         id = cdoc.registerObject(vobj);\r
 106                         Cache.log.debug("Registering new object and returning null for getvObj2jv");\r
 107                         return null;\r
 108                 }\r
 109                 if (vobj2jv.containsKey(vobj.getVorbaId()))\r
 110                         return vobj2jv.get(id);\r
 111                 return null;\r
 112         }\r
 113         protected void bindjvvobj(Object jvobj, org.vamsas.client.Vobject vobj) {\r
 114                 VorbaId id = vobj.getVorbaId();\r
 115                 if (id==null) {\r
 116                         id = cdoc.registerObject(vobj);\r
 117                 }\r
 118                 if (vobj2jv.containsKey(vobj.getVorbaId())||jv2vobj.containsKey(jvobj)) {\r
 119                         Cache.log.error("Duplicate object binding!");\r
 120                 } else {\r
 121                         vobj2jv.put(vobj.getVorbaId(),jvobj);// JBPNote - better implementing a hybrid invertible hash.\r
 122                         jv2vobj.put(jvobj,vobj.getVorbaId());                           \r
 123                 }\r
 124         }\r
 125         \r
 126         public void storeVAMSAS(AlignViewport av) \r
 127         {\r
 128                 long time = System.currentTimeMillis();\r
 129                 \r
 130                 try\r
 131                 {\r
 132                         \r
 133                         jalview.datamodel.AlignmentI jal = av.getAlignment();\r
 134                         \r
 135                         \r
 136                         ///////////////////////////////////////////\r
 137                         // SAVE THE DATASET\r
 138                         VAMSAS root = cdoc.getVamsasRoots()[0];\r
 139                         if (jal.getDataset()==null) {\r
 140                                 Cache.log.warn("Creating new dataset for an alignment.");\r
 141                                 jal.setDataset(null); // \r
 142                         }\r
 143                         boolean nw=false;\r
 144                         DataSet dataset = (DataSet) getjv2vObj(jal.getDataset());\r
 145                         if (dataset==null) {\r
 146                                 dataset = new DataSet();\r
 147                                 root.addDataSet(dataset);\r
 148                                 bindjvvobj(jal.getDataset(),dataset);\r
 149                                 nw=true;\r
 150                         } //else {\r
 151                         // should really check root corresponds to dataset.\r
 152                         // }\r
 153                         // update dataset\r
 154                         Sequence sequence;\r
 155                         DbRef dbref;\r
 156                         for (int i = 0; i < jal.getHeight(); i++)\r
 157                         {\r
 158                                 SequenceI sq = jal.getDataset().getSequenceAt(i);\r
 159                                 sequence = (Sequence) getjv2vObj(sq);\r
 160                                 if (sequence==null) {\r
 161                                         sequence=new Sequence();\r
 162                                         bindjvvobj(sq, sequence);\r
 163                                         sq.setVamsasId(sequence.getVorbaId().getId());\r
 164                                         sequence.setSequence(sq.getSequence());\r
 165                                         sequence.setName(jal.getDataset().getSequenceAt(i).getName());\r
 166                                         sequence.setStart(jal.getDataset().getSequenceAt(i).getStart());\r
 167                                         sequence.setEnd(jal.getDataset().getSequenceAt(i).getEnd());\r
 168                                         dataset.addSequence(sequence);\r
 169                                 } else {\r
 170                                         // verify principal attributes.\r
 171                                         \r
 172                                 }\r
 173                                 \r
 174                                 if(jal.getDataset().getSequenceAt(i).getSequenceFeatures()!=null)\r
 175                                 {\r
 176                                         int sfSize = jal.getDataset().getSequenceAt(i).getSequenceFeatures().length;\r
 177                                         \r
 178                                         for (int sf = 0; sf < sfSize; sf++)\r
 179                                         {\r
 180                                                 jalview.datamodel.SequenceFeature feature =\r
 181                                                         (jalview.datamodel.SequenceFeature)\r
 182                                                         jal.getDataset().getSequenceAt(i).getSequenceFeatures()[sf];\r
 183                                                 \r
 184                                                 DataSetAnnotations dsa = (DataSetAnnotations) getjv2vObj(feature); \r
 185                                                 if (dsa==null) {\r
 186                                                         dsa = new DataSetAnnotations();\r
 187                                                         bindjvvobj(feature, dsa);\r
 188                                                         dsa.setType(feature.getType());\r
 189                                                         dsa.setBegin(feature.getBegin());\r
 190                                                         dsa.setEnd(feature.getEnd());\r
 191                                                         dsa.setDescription(feature.getDescription());\r
 192                                                         dsa.setStatus(feature.getStatus());\r
 193                                                         if (dsa.getProvenance()==null) {\r
 194                                                                 dsa.setProvenance(new Provenance());\r
 195                                                         }\r
 196                                                         \r
 197                                                         dsa.getProvenance().addEntry(provEntry); // JBPNote - need to update jalview datamodel.\r
 198                                                         dsa.setSeqRef(sequence);\r
 199                                                         dataset.addDataSetAnnotations(dsa);\r
 200                                                 } else {\r
 201                                                         // todo: verify\r
 202                                                 }\r
 203                                         }\r
 204                                 }\r
 205                                 \r
 206                                 if(jal.getDataset().getSequenceAt(i).getDBRef()!=null)\r
 207                                 {\r
 208                                         java.util.Vector entries = jal.getDataset().getSequenceAt(i).getDBRef();\r
 209                                         jalview.datamodel.DBRefEntry dbentry;\r
 210                                         for(int db=0; db<entries.size(); db++)\r
 211                                         {\r
 212                                                 dbentry = (jalview.datamodel.DBRefEntry)entries.elementAt(db);\r
 213                                                 dbref = (DbRef) getjv2vObj(dbentry);\r
 214                                                 if (dbref==null) {\r
 215                                                         dbref = new DbRef();\r
 216                                                         bindjvvobj(dbentry, dbref);\r
 217                                                         dbref.setAccessionId( dbentry.getAccessionId() );\r
 218                                                         dbref.setSource( dbentry.getSource() );\r
 219                                                         dbref.setVersion( dbentry.getVersion() );\r
 220                                                         dbref.setId("db"+(time++));\r
 221                                                         sequence.addDbRef(dbref);\r
 222                                                 } else {\r
 223                                                         // todo: verify\r
 224                                                 }\r
 225                                         }\r
 226                                         \r
 227                                 }\r
 228                                 \r
 229                                 /* not needed any more.\r
 230                                 if(jal.getDataset().getSequenceAt(i).getVamsasId()==null)\r
 231                                         sequence.setId("ds" + (time++));\r
 232                                 else\r
 233                                         sequence.setId(jal.getDataset().getSequenceAt(i).getVamsasId());\r
 234                                  */\r
 235                         }\r
 236                         // dataset.setProvenance(getVamsasProvenance(jal.getDataset().getProvenance()));\r
 237                         //////////////////////////////////////////////\r
 238                         \r
 239                         \r
 240                         //////////////////////////////////////////////\r
 241                         //Save the Alignments\r
 242                         \r
 243                         Alignment alignment = (Alignment) getjv2vObj(jal);\r
 244                         if (alignment==null) {\r
 245                                 alignment=new Alignment();\r
 246                                 bindjvvobj(jal, alignment);\r
 247                                 if (alignment.getProvenance()==null)\r
 248                                         alignment.setProvenance(new Provenance());\r
 249                                 alignment.getProvenance().addEntry(provEntry);\r
 250                                 dataset.addAlignment(alignment);\r
 251                                 alignment.setGapChar(av.getGapCharacter() + "");\r
 252                                 AlignmentSequence alseq = null;\r
 253                                 for (int i = 0; i < jal.getHeight(); i++)\r
 254                                 {\r
 255                                         alseq = new AlignmentSequence();\r
 256                                         alseq.setSequence(\r
 257                                                         jal.getSequenceAt(i).getSequence()\r
 258                                         );\r
 259                                         alseq.setName(jal.getSequenceAt(i).getName());\r
 260                                         alseq.setStart(jal.getSequenceAt(i).getStart());\r
 261                                         alseq.setEnd(jal.getSequenceAt(i).getEnd());\r
 262                                         // how is this going to work ? find alseq in DataSet by..\r
 263                                         if (nw) {\r
 264                                                 // order is conserved because we just created a new dataset.\r
 265                                                 alseq.setRefid(dataset.getSequence(i));\r
 266                                         }\r
 267                                         alignment.addAlignmentSequence(alseq);\r
 268                                 }\r
 269                         } else {\r
 270                                 // todo: verify and update mutable alignment props.\r
 271                         }\r
 272                         //////////////////////////////////////////////\r
 273                         \r
 274                         \r
 275                         \r
 276                         //////////////////////////////////////////////\r
 277                         //SAVE ANNOTATIONS\r
 278                         if (jal.getAlignmentAnnotation() != null)\r
 279                         {\r
 280                                 jalview.datamodel.AlignmentAnnotation[] aa = jal.getAlignmentAnnotation();\r
 281                                 \r
 282                                 for (int i = 0; i < aa.length; i++)\r
 283                                 {\r
 284                                         if (aa[i].label.equals("Quality") ||\r
 285                                                         aa[i].label.equals("Conservation") ||\r
 286                                                         aa[i].label.equals("Consensus"))\r
 287                                         {\r
 288                                                 continue;\r
 289                                         }\r
 290                                         AlignmentAnnotations an = (AlignmentAnnotations) getjv2vObj(aa[i]);\r
 291                                         if (an==null) {\r
 292                                                 an = new AlignmentAnnotations();\r
 293                                                 an.setDescription(aa[i].description);\r
 294                                                 // JBPNote - have to deal with the many lines for one graph thing\r
 295                                                 if (aa[i].graph>0)\r
 296                                                         an.setGraph(true); //aa[i].graph);\r
 297                                                 // JBPNote - store graphGroup in the Jalview specific bits.\r
 298                                                 an.setLabel(aa[i].label);\r
 299                                                 an.setProvenance(dummyProvenance());\r
 300                                                 \r
 301                                                 AnnotationElement ae;\r
 302                                                 \r
 303                                                 for (int a = 0; a < aa[i].annotations.length; a++)\r
 304                                                 {\r
 305                                                         if ((aa[i] == null) || (aa[i].annotations[a] == null))\r
 306                                                         {\r
 307                                                                 continue;\r
 308                                                         }\r
 309                                                         \r
 310                                                         ae = new AnnotationElement();\r
 311                                                         ae.setDescription(aa[i].annotations[a].description);\r
 312                                                         ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter);\r
 313                                                         ae.setValue(aa[i].annotations[a].value);\r
 314                                                         ae.setPosition(a);\r
 315                                                         ae.setSecondaryStructure(aa[i].annotations[a].secondaryStructure +\r
 316                                                         "");\r
 317                                                         an.addAnnotationElement(ae);\r
 318                                                 }\r
 319                                                 \r
 320                                                 alignment.addAlignmentAnnotations(an);\r
 321                                         } else {\r
 322                                                 // verify annotation - update (perhaps)\r
 323                                         }\r
 324                                 }\r
 325                         }\r
 326                         ///////////////////////////////////////////////////////\r
 327                         \r
 328                         ////////////////////////////////////////////////\r
 329                         ///SAVE THE TREES\r
 330                         ///////////////////////////////////\r
 331                         // FIND ANY ASSOCIATED TREES\r
 332                         if (Desktop.desktop != null)\r
 333                         {\r
 334                                 javax.swing.JInternalFrame[] frames = Desktop.desktop.getAllFrames();\r
 335                                 \r
 336                                 for (int t = 0; t < frames.length; t++)\r
 337                                 {\r
 338                                         if (frames[t] instanceof TreePanel)\r
 339                                         {\r
 340                                                 TreePanel tp = (TreePanel) frames[t];\r
 341                                                 \r
 342                                                 if (tp.getAlignment() == jal)\r
 343                                                 {\r
 344                                                         // JBPNote - can recover alignment and Vamsas Alignment for an associated tree using the getjv2vObj()\r
 345                                                         \r
 346                                                         Tree tree = (Tree) getjv2vObj(tp);\r
 347                                                         if (tree==null) {\r
 348                                                                 tree = new Tree();\r
 349                                                                 bindjvvobj(tp,tree);\r
 350                                                                 tree.setTitle(tp.getTitle());\r
 351                                                                 Newick newick = new Newick();\r
 352                                                                 newick.setContent( tp.getTree().toString() );\r
 353                                                                 newick.setTitle( tp.getTitle() );\r
 354                                                                 tree.addNewick( newick );\r
 355                                                                 tree.setProvenance(dummyProvenance());\r
 356                                                                 alignment.addTree(tree);\r
 357                                                         } else {\r
 358                                                                 // verify any changes.\r
 359                                                         }\r
 360                                                 }\r
 361                                         }\r
 362                                 }\r
 363                         }\r
 364                 }\r
 365                 \r
 366                 catch (Exception ex)\r
 367                 {\r
 368                         ex.printStackTrace();\r
 369                 }\r
 370                 \r
 371         }\r
 372         \r
 373         \r
 374         \r
 375         public void updateJalview()\r
 376         {\r
 377                 VAMSAS root = cdoc.getVamsasRoots()[0];\r
 378                 try\r
 379                 {\r
 380                         boolean newds=false;\r
 381                         for (int _ds=0,_nds=root.getDataSetCount(); _ds<_nds; _ds++) {\r
 382                                 /////////////////////////////////////\r
 383                                 /////LOAD DATASET\r
 384                                 DataSet dataset = vamsas.getDataSet(_ds);\r
 385                                 int i, iSize = dataset.getSequenceCount();\r
 386                                 jalview.datamodel.Alignment jdataset = (jalview.datamodel.Alignment) vobj2jv(dataset);\r
 387                                 if (jdataset!=null) {\r
 388                                         // recover\r
 389                                 } else {\r
 390                                         newds=true;\r
 391                                         // construct new dataset\r
 392                                         jalview.datamodel.Sequence [] seqs = new jalview.datamodel.Sequence[iSize];\r
 393                                         DbRef [] dbref;\r
 394                                         for (i = 0; i < iSize ; i++)\r
 395                                         {\r
 396                                                 seqs[i] = new jalview.datamodel.Sequence(\r
 397                                                                 dataset.getSequence(i).getName(),\r
 398                                                                 dataset.getSequence(i).getSequence(),\r
 399                                                                 dataset.getSequence(i).getStart(),\r
 400                                                                 dataset.getSequence(i).getEnd()  );\r
 401                                                 bindjvvobj(seqs[i], dataset.getSequence(i));\r
 402                                                 seqs[i].setVamsasId(dataset.getSequence(i).getVorbaId().getId());\r
 403                                                 \r
 404                                                 if (dataset.getDataSetAnnotations() != null)\r
 405                                                 {\r
 406                                                         for (int dsa = 0; dsa < dataset.getDataSetAnnotationsCount(); dsa++)\r
 407                                                         {\r
 408                                                                 // could be optimised\r
 409                                                                 if (dataset.getDataSetAnnotations(dsa).getSeqRef() ==\r
 410                                                                         dataset.getSequence(i))\r
 411                                                                 {\r
 412                                                                         jalview.datamodel.SequenceFeature sf;\r
 413                                                                         seqs[i].addSequenceFeature(sf=new jalview.datamodel.\r
 414                                                                                         SequenceFeature(\r
 415                                                                                                         dataset.getDataSetAnnotations(dsa).getType(),\r
 416                                                                                                         dataset.getDataSetAnnotations(dsa).getDescription(),\r
 417                                                                                                         dataset.getDataSetAnnotations(dsa).getStatus(),\r
 418                                                                                                         dataset.getDataSetAnnotations(dsa).getBegin(),\r
 419                                                                                                         dataset.getDataSetAnnotations(dsa).getEnd(),\r
 420                                                                                         "vamsas"));\r
 421                                                                         bindjvvobj(sf, dataset.getDataSetAnnotations(dsa));\r
 422                                                                 }\r
 423                                                         }\r
 424                                                 }\r
 425                                                 dbref = dataset.getSequence(i).getDbRef();\r
 426                                                 \r
 427                                                 if(dbref.length>0)\r
 428                                                 {\r
 429                                                         for(int db=0; db<dbref.length; db++)\r
 430                                                         {\r
 431                                                                 jalview.datamodel.DBRefEntry dbr;\r
 432                                                                 seqs[i].addDBRef(dbr= new jalview.datamodel.DBRefEntry\r
 433                                                                                 (\r
 434                                                                                                 dbref[db].getSource().toString(),\r
 435                                                                                                 dbref[db].getVersion().toString(),\r
 436                                                                                                 dbref[db].getAccessionId().toString()));\r
 437                                                                 bindjvvobj(dbr, dvref[db]);\r
 438                                                         }\r
 439                                                 }\r
 440                                         }\r
 441                                         jdataset = jalview.datamodel.Alignment(seqs); // complete construction\r
 442                                         bindjvvobj(jdataset, dataset);\r
 443                                 }\r
 444                                 ////////////////////////////////////////////////\r
 445                         }\r
 446                         for (int _al=0,_nal=dataset.getAlignmentCount(); _al<_nal; _al++) {\r
 447                                 //////////////////////////////////////\r
 448                                 ////LOAD ALIGNMENT\r
 449                                 Alignment alignment = dataset.getAlignment(_al);\r
 450                                 iSize = alignment.getAlignmentSequenceCount();\r
 451                                 jalview.datamodel.Alignment jal = getvObj2jv(alignment); \r
 452                                 if (jal!=null) {\r
 453                                         // merge/update\r
 454                                 } else {\r
 455                                         seqs = new jalview.datamodel.Sequence[iSize];\r
 456                                         String id;\r
 457                                         int j, jSize = jdataset.getHeight();\r
 458                                         for (i = 0; i < iSize; i++)\r
 459                                         {\r
 460                                                 seqs[i] = new jalview.datamodel.Sequence(\r
 461                                                                 alignment.getAlignmentSequence(i).getName(),\r
 462                                                                 alignment.getAlignmentSequence(i).getSequence(),\r
 463                                                                 alignment.getAlignmentSequence(i).getStart(),\r
 464                                                                 alignment.getAlignmentSequence(i).getEnd());\r
 465                                                 bindjvvobj(seqs[i], alignment.getAlignmentSequence(i));\r
 466                                                 id = ( (Sequence) alignment.getAlignmentSequence(i).getRefid()).getVorbaId().getId();\r
 467                                                 \r
 468                                                 for(j=0; j<jSize; j++)\r
 469                                                 {\r
 470                                                         if(jdataset.getSequenceAt(j).getVamsasId().equals(id))\r
 471                                                         {\r
 472                                                                 seqs[i].setDatasetSequence( jdataset.getSequenceAt(j) );\r
 473                                                                 break;\r
 474                                                         }\r
 475                                                 }\r
 476                                         }\r
 477                                         jalview.datamodel.Alignment jal = new jalview.datamodel.Alignment(seqs);\r
 478                                         bindjvvobj(jal, alignment);\r
 479                                         jal.setDataset(jdataset);\r
 480                                         /*jal.getDataset().setProvenance(\r
 481                         getJalviewProvenance(dataset.getProvenance()));\r
 482                         jal.setProvenance(\r
 483                         getJalviewProvenance(alignment.getProvenance()));\r
 484                                          */\r
 485                                         //////////////////////////////////////////////\r
 486                                         \r
 487                                         \r
 488                                         ////////////////////////////////////////////\r
 489                                         ////LOAD ANNOTATIONS\r
 490                                         ////////////////////\r
 491                                         if (alignment.getAlignmentAnnotationsCount()>0)\r
 492                                         {\r
 493                                                 AlignmentAnnotations[] an = alignment.getAlignmentAnnotations();\r
 494                                                 \r
 495                                                 for (j = 0; j < an.length; j++)\r
 496                                                 {\r
 497                                                         boolean topaliBreakpoint = false;\r
 498                                                         \r
 499                                                         AnnotationElement[] ae = an[j].getAnnotationElement();\r
 500                                                         jalview.datamodel.Annotation[] anot = getvObj2jv(ae);\r
 501                                                         if (anot!=null) {\r
 502                                                                 // update or stay the same.\r
 503                                                         } else {\r
 504                                                                 // new one\r
 505                                                                 anot=new jalview.datamodel.Annotation[jal.\r
 506                                                                  getWidth()];\r
 507                                                                 bindjvvobj(anot, ae);\r
 508                                 try{\r
 509                                         for (int aa = 0; aa < ae.length; aa++)\r
 510                                         {\r
 511                                                 String dc = ae[aa].getDisplayCharacter()==null ? "dc" : ae[aa].getDisplayCharacter();\r
 512                                                 String desc = ae[aa].getDescription()==null ? "desc" : ae[aa].getDescription();\r
 513                                                 String ss = ae[aa].getSecondaryStructure()==null ? "ss" : ae[aa].getSecondaryStructure();\r
 514                                                 float value = ae[aa].getValue();\r
 515                                                 if(an[j].getGraph())\r
 516                                                 {\r
 517                                                         dc = value+"";\r
 518                                                         desc = value + "";\r
 519                                                 }\r
 520                                                 anot[ae[aa].getPosition()-1] = new jalview.datamodel.\r
 521                                                 Annotation(dc,desc,ss.charAt(0),value);\r
 522                                                                         \r
 523                                                 if(desc.equals("TOPALi Partition Breakpoint"))\r
 524                                                                                 topaliBreakpoint = true;\r
 525                                                                         \r
 526                                         }\r
 527                                 }catch(Exception ex)\r
 528                                 {\r
 529                                         ex.printStackTrace();\r
 530                                         System.out.println("problem parsing annotations\n"+ex);}\r
 531                                 }\r
 532                                                         jalview.datamodel.AlignmentAnnotation jaa = null;\r
 533                                                         if (an[j].getGraph())\r
 534                                                         {\r
 535                                                                 jaa = new jalview.datamodel.AlignmentAnnotation(an[j].getLabel(),\r
 536                                                                                 an[j].getDescription(), anot, 0, 0, 1);\r
 537                                                         }\r
 538                                                         else\r
 539                                                         {\r
 540                                                                 String label = an[j].getLabel();\r
 541                                                                 if(topaliBreakpoint)\r
 542                                                                         label = "TOPALi Partition Breakpoint";\r
 543                                                                 jaa = new jalview.datamodel.AlignmentAnnotation(label,\r
 544                                                                                 an[j].getDescription(), anot);\r
 545                                                         }\r
 546                                                         \r
 547                                                         jal.addAnnotation(jaa);\r
 548                                                 }\r
 549                                         }\r
 550                                         /////////////////////////////////\r
 551                                         \r
 552                                         AlignFrame alignFrame = new AlignFrame(jal);\r
 553                                         jalview.gui.Desktop.addInternalFrame(alignFrame, "VAMSAS LOAD",\r
 554                                                         AlignFrame.NEW_WINDOW_WIDTH,\r
 555                                                         AlignFrame.NEW_WINDOW_HEIGHT);\r
 556                                         \r
 557                                         //LOAD TREES\r
 558                                         ///////////////////////////////////////\r
 559                                         if (alignment.getTreeCount() > 0)\r
 560                                         {\r
 561                                                 for (int t = 0; t < alignment.getTreeCount(); t++)\r
 562                                                 {\r
 563                                                         Tree tree = alignment.getTree(t);\r
 564                                                         \r
 565                                                         alignFrame.ShowNewickTree(\r
 566                                                                         new jalview.io.NewickFile(tree.getNewick(0).getContent()),\r
 567                                                                         tree.getNewick(0).getTitle(),\r
 568                                                                         600, 500,\r
 569                                                                         t * 20 + 50, t * 20 + 50);\r
 570                                                 }\r
 571                                         }\r
 572                                         \r
 573                                         \r
 574                                         in.close();\r
 575                                         jin.close();\r
 576                                 }\r
 577                                 catch (Exception ex)\r
 578                                 {\r
 579                                         ex.printStackTrace();\r
 580                                 }\r
 581                                 \r
 582                                 \r
 583                         }\r
 584                         \r
 585                         \r
 586                         \r
 587                         Provenance getVamsasProvenance(jalview.datamodel.Provenance jprov)\r
 588                         {\r
 589                                 jalview.datamodel.ProvenanceEntry [] entries = null;\r
 590                                 \r
 591                                 \r
 592                                 Provenance prov = new Provenance();\r
 593                                 org.exolab.castor.types.Date date = new org.exolab.castor.types.Date(\r
 594                                                 new java.util.Date());\r
 595                                 Entry provEntry;\r
 596                                 \r
 597                                 if(jprov!=null)\r
 598                                 {\r
 599                                         entries = jprov.getEntries();\r
 600                                         for (int i = 0; i < entries.length; i++)\r
 601                                         {\r
 602                                                 provEntry = new Entry();\r
 603                                                 try\r
 604                                                 {\r
 605                                                         date = new org.exolab.castor.types.Date(entries[i].getDate());\r
 606                                                 }\r
 607                                                 catch (Exception ex)\r
 608                                                 {\r
 609                                                         ex.printStackTrace();\r
 610                                                         \r
 611                                                         date = new org.exolab.castor.types.Date(entries[i].getDate());\r
 612                                                 }\r
 613                                                 provEntry.setDate(date);\r
 614                                                 provEntry.setUser(entries[i].getUser());\r
 615                                                 provEntry.setAction(entries[i].getAction());\r
 616                                                 prov.addEntry(provEntry);\r
 617                                         }\r
 618                                 }\r
 619                                 else\r
 620                                 {\r
 621                                         provEntry = new Entry();\r
 622                                         provEntry.setDate(date);\r
 623                                         provEntry.setUser(System.getProperty("user.name"));\r
 624                                         provEntry.setAction("Jalview");\r
 625                                         prov.addEntry(provEntry);\r
 626                                 }\r
 627                                 \r
 628                                 return prov;\r
 629                         }\r
 630                         \r
 631                         jalview.datamodel.Provenance getJalviewProvenance(Provenance prov)\r
 632                         {\r
 633                                 \r
 634                                 jalview.datamodel.Provenance jprov = new jalview.datamodel.Provenance();\r
 635                                 for (int i = 0; i < prov.getEntryCount(); i++)\r
 636                                 {\r
 637                                         jprov.addEntry(\r
 638                                                         prov.getEntry(i).getUser(),\r
 639                                                         prov.getEntry(i).getAction(),\r
 640                                                         prov.getEntry(i).getDate().toDate(),\r
 641                                                         prov.getEntry(i).getId()\r
 642                                         );\r
 643                                 }\r
 644                                 \r
 645                                 return jprov;\r
 646                         }\r
 647                         \r
 648                         Provenance dummyProvenance()\r
 649                         {\r
 650                                 Provenance prov = new Provenance();\r
 651                                 Entry entry = new Entry();\r
 652                                 entry.setAction("Jalview");\r
 653                                 entry.setDate(new org.exolab.castor.types.Date(new java.util.Date()));\r
 654                                 entry.setUser(System.getProperty("user.name"));\r
 655                                 prov.addEntry(entry);\r
 656                                 return prov;\r
 657                         }\r
 658                         \r
 659                 }\r