From: jprocter <Jim Procter>
Date: Sat, 25 Mar 2006 16:33:09 +0000 (+0000)
Subject: basic VamsasSession gui bits.
X-Git-Url: http://source.jalview.org/gitweb/?a=commitdiff_plain;h=536f598943c69945bedda1b25cd1a205f2d48ea9;p=jalview.git

basic VamsasSession gui bits.
---

diff --git a/build.xml b/build.xml
index ae21307..189260f 100755
--- a/build.xml
+++ b/build.xml
@@ -67,6 +67,10 @@
           <include name="*.jar"/>
           <include name="**/*.jar"/>
         </fileset>
+        	<fileset dir="../VamsasClient/packages">
+        		<include name="*.jar"/>
+       			<include name="**/*.jar"/>
+		</fileset>
 <!--        <fileset dir="old_lib_signed">
 <include name="lib_axis.jar"/>
 
@@ -131,6 +135,9 @@
         <fileset dir="${resourceDir}">
           <include name="**/*.*"/>
         </fileset>
+      	<fileset dir="../VamsasClient/packages/">
+     	  <include name="**/*.jar"/>
+      	</fileset>
       </copy>
     </target>
 
diff --git a/src/jalview/gui/Desktop.java b/src/jalview/gui/Desktop.java
index 9085b1e..3bc2613 100755
--- a/src/jalview/gui/Desktop.java
+++ b/src/jalview/gui/Desktop.java
@@ -27,6 +27,8 @@ import java.awt.event.*;
 
 import javax.swing.*;
 
+import org.vamsas.test.simpleclient.ArchiveClient;
+
 
 /**
  * DOCUMENT ME!
@@ -576,32 +578,47 @@ public class Desktop extends jalview.jbgui.GDesktop
             Jalview2XML.LoadJalviewAlign(choice);
         }
     }
-
-  /*  public void vamsasLoad_actionPerformed(ActionEvent e)
+    jalview.io.VamsasClient v_client=null;
+    public void vamsasLoad_actionPerformed(ActionEvent e)
     {
-      JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.
-          getProperty("LAST_DIRECTORY"));
+      if (v_client==null) {
+        // Start a session.
+        JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.
+            getProperty("LAST_DIRECTORY"));
 
-      chooser.setFileView(new JalviewFileView());
-      chooser.setDialogTitle("Load Vamsas file");
-      chooser.setToolTipText("Import");
+        chooser.setFileView(new JalviewFileView());
+        chooser.setDialogTitle("Load Vamsas file");
+        chooser.setToolTipText("Import");
 
-      int value = chooser.showOpenDialog(this);
+        int value = chooser.showOpenDialog(this);
 
-      if (value == JalviewFileChooser.APPROVE_OPTION)
-      {
-        jalview.io.VamsasDatastore vs = new jalview.io.VamsasDatastore(null);
-        vs.load(
-            chooser.getSelectedFile().getAbsolutePath()
-            );
+        if (value == JalviewFileChooser.APPROVE_OPTION)
+        {
+          v_client = new jalview.io.VamsasClient(this,
+              chooser.getSelectedFile().getAbsolutePath()
+              );
+          this.vamsasLoad.setText("Session Update");
+          this.vamsasStop.setVisible(true);
+          v_client.initial_update();
+        }
+      } else {
+        // store current data in session.
+    	  v_client.push_update();
       }
-
-    }*/
-
-
+    }
+    public void vamsasStop_actionPerformed(ActionEvent e) {
+    	if (v_client!=null) {
+    		v_client.end_session();
+    		v_client=null;
+    		this.vamsasStop.setVisible(false);
+    		this.vamsasLoad.setText("Start Vamsas Session...");
+    	}
+    }
+    
     public void inputSequence_actionPerformed(ActionEvent e)
     {
       SequenceFetcher sf = new SequenceFetcher(null);
     }
+
 }
 
diff --git a/src/jalview/io/VamsasClient.java b/src/jalview/io/VamsasClient.java
new file mode 100755
index 0000000..ca62b09
--- /dev/null
+++ b/src/jalview/io/VamsasClient.java
@@ -0,0 +1,67 @@
+/**
+ * 
+ */
+package jalview.io;
+
+import jalview.bin.Cache;
+import jalview.gui.Desktop;
+
+import org.vamsas.client.UserHandle;
+import org.vamsas.client.simpleclient.FileWatcher;
+import org.vamsas.client.simpleclient.VamsasArchive;
+import org.vamsas.client.simpleclient.VamsasFile;
+import org.vamsas.test.simpleclient.ArchiveClient;
+
+/**
+ * @author jimp
+ *
+ */
+public class VamsasClient extends ArchiveClient {
+	Desktop us;
+	public VamsasClient(Desktop jdesktop,
+			String sessionPath) {
+		super("Jalview User", "Dundee", // new org.vamsas.client.ClientHandle("jalview","2.7"),
+				sessionPath);
+		us=jdesktop;
+	}
+	public void initial_update() {
+		Cache.log.info("Jalview loading the Vamsas Session.");
+		// load in the vamsas archive for the first time
+		
+		// VamsasArchive doc = new VamsasArchive();
+	}
+	public void get_update(VamsasArchive doc) {
+		Cache.log.info("Jalview updating from Vamsas Session.");
+	}
+	public void push_update() {
+		// collect all uncached alignments and put them into the vamsas dataset.
+		// store them.
+		Cache.log.info("Jalview updating the Vamsas Session.");
+	}
+	public void end_session() {
+		// stop any update/watcher thread.
+		Cache.log.info("Jalview disconnecting from the Vamsas Session.");
+	}
+	protected class VamsasClientWatcher extends Thread implements Runnable {
+		/* (non-Javadoc)
+		 * @see java.lang.Thread#run()
+		 */
+		VamsasClient client=null;
+		VamsasClientWatcher(VamsasClient client) {
+			this.client = client;
+		}
+		public void run() {
+			VamsasArchive docio = client.watch(0);
+			client.get_update(docio);
+		}
+		
+	}
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/src/jalview/io/VamsasDatastore.java b/src/jalview/io/VamsasDatastore.java
new file mode 100755
index 0000000..6b793c6
--- /dev/null
+++ b/src/jalview/io/VamsasDatastore.java
@@ -0,0 +1,578 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+package jalview.io;
+
+import org.vamsas.objects.core.*;
+
+import jalview.gui.*;
+import java.io.*;
+import java.util.jar.*;
+import org.exolab.castor.xml.*;
+import org.exolab.castor.mapping.Mapping;
+
+/*
+
+ static {
+ org.exolab.castor.util.LocalConfiguration.getInstance().getProperties().setProperty(
+ "org.exolab.castor.serializer", "org.apache.xml.serialize.XMLSerilazizer");
+ }
+
+*/
+
+public class VamsasDatastore
+{
+	AlignViewport av;
+        org.exolab.castor.types.Date date
+              = new org.exolab.castor.types.Date(new java.util.Date());
+
+	public VamsasDatastore(AlignViewport av)
+	{
+		this.av = av;
+	}
+
+        public void store(String file)
+        {
+          storeVAMSAS(file);
+        }
+
+        public void storeJalview(String file, AlignFrame af)
+        {
+          try
+          {
+            // 1. Load the mapping information from the file
+            Mapping map = new Mapping(getClass().getClassLoader());
+            java.net.URL url = getClass().getResource("/jalview_mapping.xml");
+            map.loadMapping(url);
+
+            // 2. Unmarshal the data
+            // Unmarshaller unmar = new Unmarshaller();
+            //unmar.setIgnoreExtraElements(true);
+            //unmar.setMapping(map);
+            // uni = (UniprotFile) unmar.unmarshal(new FileReader(file));
+
+            // 3. marshal the data with the total price back and print the XML in the console
+              Marshaller marshaller = new Marshaller( new FileWriter(file) );
+
+             marshaller.setMapping(map);
+             marshaller.marshal(af);
+          }
+          catch (Exception e)
+          {
+            e.printStackTrace();
+          }
+        }
+
+
+
+        public VAMSAS storeVAMSAS(String file)
+        {
+          long time = System.currentTimeMillis();
+          VAMSAS vamsas = new VAMSAS();
+
+          try
+          {
+            FileOutputStream fos = new FileOutputStream(file);
+            JarOutputStream jout = new JarOutputStream(fos);
+
+
+            ////////////////////////////////////////////////////
+            //NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
+            PrintWriter out = new PrintWriter(new OutputStreamWriter(jout,
+                "UTF-8"));
+
+            jalview.datamodel.AlignmentI jal = av.getAlignment();
+
+
+            ///////////////////////////////////////////
+            // SAVE THE DATASET
+            DataSet dataset = new DataSet();
+            vamsas.addDataSet(dataset);
+
+            Sequence sequence;
+            DbRef dbref;
+            for (int i = 0; i < jal.getHeight(); i++)
+            {
+              sequence = new Sequence();
+              sequence.setSequence(jal.getDataset().getSequenceAt(i).getSequence());
+              sequence.setName(jal.getDataset().getSequenceAt(i).getName());
+              sequence.setStart(jal.getDataset().getSequenceAt(i).getStart());
+              sequence.setEnd(jal.getDataset().getSequenceAt(i).getEnd());
+
+
+              if(jal.getDataset().getSequenceAt(i).getSequenceFeatures()!=null)
+              {
+                int sfSize = jal.getDataset().getSequenceAt(i).getSequenceFeatures().length;
+
+                for (int sf = 0; sf < sfSize; sf++)
+                {
+                  jalview.datamodel.SequenceFeature feature =
+                      (jalview.datamodel.SequenceFeature)
+                      jal.getDataset().getSequenceAt(i).getSequenceFeatures()[sf];
+
+                  DataSetAnnotations dsa = new DataSetAnnotations();
+                  dsa.setType(feature.getType());
+                  dsa.setBegin(feature.getBegin());
+                  dsa.setEnd(feature.getEnd());
+                  dsa.setDescription(feature.getDescription());
+                  dsa.setStatus(feature.getStatus());
+                  dsa.addProvenance(dummyProvenance());
+                  dsa.setSeqRef(sequence);
+                  dsa.setId("sf"+(time++));
+                  dataset.addDataSetAnnotations(dsa);
+                }
+              }
+
+              if(jal.getDataset().getSequenceAt(i).getDBRef()!=null)
+              {
+                java.util.Vector entries = jal.getDataset().getSequenceAt(i).getDBRef();
+                jalview.datamodel.DBRefEntry dbentry;
+                for(int db=0; db<entries.size(); db++)
+                {
+                  dbentry = (jalview.datamodel.DBRefEntry)entries.elementAt(db);
+                  dbref = new DbRef();
+                  dbref.setAccessionId( dbentry.getAccessionId() );
+                  dbref.setSource( dbentry.getSource() );
+                  dbref.setVersion( dbentry.getVersion() );
+                  dbref.setId("db"+(time++));
+                  sequence.addDbRef(dbref);
+                }
+
+              }
+
+
+              if(jal.getDataset().getSequenceAt(i).getVamsasId()==null)
+                sequence.setId("ds" + (time++));
+              else
+                sequence.setId(jal.getDataset().getSequenceAt(i).getVamsasId());
+
+              dataset.addSequence(sequence);
+            }
+            // dataset.setProvenance(getVamsasProvenance(jal.getDataset().getProvenance()));
+            //////////////////////////////////////////////
+
+
+            //////////////////////////////////////////////
+            //Save the Alignments
+            Alignment alignment = new Alignment();
+            alignment.setGapChar(av.getGapCharacter() + "");
+            AlignmentSequence alseq = null;
+            for (int i = 0; i < jal.getHeight(); i++)
+            {
+              alseq = new AlignmentSequence();
+              alseq.setSequence(
+                  jal.getSequenceAt(i).getSequence()
+                  );
+              alseq.setName(jal.getSequenceAt(i).getName());
+              alseq.setStart(jal.getSequenceAt(i).getStart());
+              alseq.setEnd(jal.getSequenceAt(i).getEnd());
+              alseq.setRefid(dataset.getSequence(i));
+              alseq.setId("as" + (time++));
+              alignment.addAlignmentSequence(alseq);
+            }
+            // alignment.setProvenance(getVamsasProvenance(jal.getProvenance()));
+            dataset.addAlignment(alignment);
+            //////////////////////////////////////////////
+
+
+
+            //////////////////////////////////////////////
+            //SAVE ANNOTATIONS
+            if (jal.getAlignmentAnnotation() != null)
+            {
+                jalview.datamodel.AlignmentAnnotation[] aa = jal.getAlignmentAnnotation();
+
+                for (int i = 0; i < aa.length; i++)
+                {
+                    if (aa[i].label.equals("Quality") ||
+                            aa[i].label.equals("Conservation") ||
+                            aa[i].label.equals("Consensus"))
+                    {
+                        continue;
+                    }
+
+                    AlignmentAnnotations an = new AlignmentAnnotations();
+
+                    an.setDescription(aa[i].description);
+                    // JBPNote - have to deal with the many lines for one graph thing
+                    if (aa[i].graph>0)
+                    	an.setGraph(true); //aa[i].graph);
+                    // JBPNote - store graphGroup in the Jalview specific bits.
+                    an.setLabel(aa[i].label);
+                    an.setProvenance(dummyProvenance());
+
+                    AnnotationElement ae;
+
+                    for (int a = 0; a < aa[i].annotations.length; a++)
+                    {
+                        if ((aa[i] == null) || (aa[i].annotations[a] == null))
+                        {
+                            continue;
+                        }
+
+                        ae = new AnnotationElement();
+                        ae.setDescription(aa[i].annotations[a].description);
+                        ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter);
+                        ae.setValue(aa[i].annotations[a].value);
+                        ae.setPosition(a);
+                        ae.setSecondaryStructure(aa[i].annotations[a].secondaryStructure +
+                            "");
+                        an.addAnnotationElement(ae);
+                    }
+
+                    alignment.addAlignmentAnnotations(an);
+                }
+            }
+            ///////////////////////////////////////////////////////
+
+
+          ////////////////////////////////////////////////
+          ///SAVE THE TREES
+          ///////////////////////////////////
+          // FIND ANY ASSOCIATED TREES
+          if (Desktop.desktop != null)
+          {
+            javax.swing.JInternalFrame[] frames = Desktop.desktop.getAllFrames();
+
+            for (int t = 0; t < frames.length; t++)
+            {
+              if (frames[t] instanceof TreePanel)
+              {
+                TreePanel tp = (TreePanel) frames[t];
+
+                if (tp.getAlignment() == jal)
+                {
+                  Tree tree = new Tree();
+                  tree.setTitle(tp.getTitle());
+                  Newick newick = new Newick();
+                  newick.setContent( tp.getTree().toString() );
+                  newick.setTitle( tp.getTitle() );
+                  newick.setId("t"+(time++));
+                  tree.addNewick( newick );
+                  tree.setProvenance(dummyProvenance());
+                  alignment.addTree(tree);
+                }
+              }
+            }
+          }
+
+
+            JarEntry entry = new JarEntry("vamsas.xml");
+            jout.putNextEntry(entry);
+
+            vamsas.marshal(out);
+
+            out.close();
+            jout.close();
+
+
+          }
+          catch (Exception ex)
+          {
+            ex.printStackTrace();
+          }
+
+          return vamsas;
+	}
+
+        Tree jalview2VamsasTree()
+        {
+          Tree tree = new Tree();
+
+          return tree;
+        }
+
+
+	public void load(String file)
+	{
+          VAMSAS vamsas = new VAMSAS() ;
+
+          try
+          {
+            FileInputStream fis = new FileInputStream(file);
+            JarInputStream jin = new JarInputStream(fis);
+
+
+            ////////////////////////////////////////////////////
+            //NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
+            InputStreamReader in = new InputStreamReader(jin, "UTF-8");
+            JarEntry jarentry = jin.getNextJarEntry();
+            System.out.println("reading: "+jarentry.getName());
+            vamsas = (VAMSAS) vamsas.unmarshal(in);
+
+
+            /////////////////////////////////////
+            /////LOAD DATASET
+            DataSet dataset = vamsas.getDataSet(0);
+
+            int i, iSize = dataset.getSequenceCount();
+            jalview.datamodel.Sequence [] seqs = new jalview.datamodel.Sequence[iSize];
+            DbRef [] dbref;
+
+            for (i = 0; i < iSize ; i++)
+            {
+              seqs[i] = new jalview.datamodel.Sequence(
+                  dataset.getSequence(i).getName(),
+                  dataset.getSequence(i).getSequence(),
+                   dataset.getSequence(i).getStart(),
+                     dataset.getSequence(i).getEnd()  );
+              seqs[i].setVamsasId(dataset.getSequence(i).getId());
+
+              if (dataset.getDataSetAnnotations() != null)
+              {
+                for (int dsa = 0; dsa < dataset.getDataSetAnnotationsCount(); dsa++)
+                {
+                  if (dataset.getDataSetAnnotations(dsa).getSeqRef() ==
+                      dataset.getSequence(i))
+                  {
+                    seqs[i].addSequenceFeature(new jalview.datamodel.
+                                               SequenceFeature(
+                        dataset.getDataSetAnnotations(dsa).getType(),
+                        dataset.getDataSetAnnotations(dsa).getDescription(),
+                        dataset.getDataSetAnnotations(dsa).getStatus(),
+                        dataset.getDataSetAnnotations(dsa).getBegin(),
+                        dataset.getDataSetAnnotations(dsa).getEnd(),
+                        "vamsas"));
+                  }
+                }
+              }
+              dbref = dataset.getSequence(i).getDbRef();
+
+              if(dbref.length>0)
+              {
+                for(int db=0; db<dbref.length; db++)
+                {
+                  seqs[i].addDBRef( new jalview.datamodel.DBRefEntry
+                      (
+                           dbref[db].getSource().toString(),
+                           dbref[db].getVersion().toString(),
+                           dbref[db].getAccessionId().toString()));
+                }
+              }
+            }
+            jalview.datamodel.Alignment jdataset = new jalview.datamodel.Alignment(seqs);
+            ////////////////////////////////////////////////
+
+
+            //////////////////////////////////////
+            ////LOAD ALIGNMENT
+            Alignment alignment = dataset.getAlignment(0);
+            iSize = alignment.getAlignmentSequenceCount();
+            seqs = new jalview.datamodel.Sequence[iSize];
+            String id;
+            int j, jSize = jdataset.getHeight();
+            for (i = 0; i < iSize; i++)
+            {
+              seqs[i] = new jalview.datamodel.Sequence(
+                  alignment.getAlignmentSequence(i).getName(),
+                  alignment.getAlignmentSequence(i).getSequence(),
+                  alignment.getAlignmentSequence(i).getStart(),
+                  alignment.getAlignmentSequence(i).getEnd());
+
+              id = ( (Sequence) alignment.getAlignmentSequence(i).getRefid()).getId();
+
+             for(j=0; j<jSize; j++)
+             {
+               if(jdataset.getSequenceAt(j).getVamsasId().equals(id))
+               {
+                 seqs[i].setDatasetSequence( jdataset.getSequenceAt(j) );
+                 break;
+               }
+             }
+            }
+            jalview.datamodel.Alignment jal = new jalview.datamodel.Alignment(seqs);
+            jal.setDataset(jdataset);
+            /*jal.getDataset().setProvenance(
+                getJalviewProvenance(dataset.getProvenance()));
+            jal.setProvenance(
+                getJalviewProvenance(alignment.getProvenance()));
+            */
+             //////////////////////////////////////////////
+
+
+            ////////////////////////////////////////////
+            ////LOAD ANNOTATIONS
+            ////////////////////
+            if (alignment.getAlignmentAnnotationsCount()>0)
+            {
+              AlignmentAnnotations[] an = alignment.getAlignmentAnnotations();
+
+              for (j = 0; j < an.length; j++)
+              {
+                boolean topaliBreakpoint = false;
+
+                AnnotationElement[] ae = an[j].getAnnotationElement();
+                jalview.datamodel.Annotation[] anot = new jalview.datamodel.Annotation[jal.
+                    getWidth()];
+
+                try{
+
+                  for (int aa = 0; aa < ae.length; aa++)
+                  {
+                    String dc = ae[aa].getDisplayCharacter()==null ? "dc" : ae[aa].getDisplayCharacter();
+                    String desc = ae[aa].getDescription()==null ? "desc" : ae[aa].getDescription();
+                    String ss = ae[aa].getSecondaryStructure()==null ? "ss" : ae[aa].getSecondaryStructure();
+                    float value = ae[aa].getValue();
+
+                    if(an[j].getGraph())
+                    {
+                      dc = value+"";
+                      desc = value + "";
+                    }
+                    anot[ae[aa].getPosition()-1] = new jalview.datamodel.
+                        Annotation(dc,desc,ss.charAt(0),value);
+
+                    if(desc.equals("TOPALi Partition Breakpoint"))
+                      topaliBreakpoint = true;
+
+                  }
+                }catch(Exception ex)
+                {
+                  ex.printStackTrace();
+                  System.out.println("problem parsing annotations\n"+ex);}
+
+                jalview.datamodel.AlignmentAnnotation jaa = null;
+
+                if (an[j].getGraph())
+                {
+                  jaa = new jalview.datamodel.AlignmentAnnotation(an[j].getLabel(),
+                      an[j].getDescription(), anot, 0, 0, 1);
+                }
+                else
+                {
+                  String label = an[j].getLabel();
+                  if(topaliBreakpoint)
+                    label = "TOPALi Partition Breakpoint";
+                  jaa = new jalview.datamodel.AlignmentAnnotation(label,
+                      an[j].getDescription(), anot);
+                }
+
+                jal.addAnnotation(jaa);
+              }
+            }
+            /////////////////////////////////
+
+            AlignFrame alignFrame = new AlignFrame(jal);
+            jalview.gui.Desktop.addInternalFrame(alignFrame, "VAMSAS LOAD",
+                                                 AlignFrame.NEW_WINDOW_WIDTH,
+                                                 AlignFrame.NEW_WINDOW_HEIGHT);
+
+            //LOAD TREES
+            ///////////////////////////////////////
+            if (alignment.getTreeCount() > 0)
+            {
+                for (int t = 0; t < alignment.getTreeCount(); t++)
+                {
+                  Tree tree = alignment.getTree(t);
+
+                  alignFrame.ShowNewickTree(
+                      new jalview.io.NewickFile(tree.getNewick(0).getContent()),
+                      tree.getNewick(0).getTitle(),
+                      600, 500,
+                      t * 20 + 50, t * 20 + 50);
+                }
+            }
+
+
+            in.close();
+            jin.close();
+          }
+          catch (Exception ex)
+          {
+            ex.printStackTrace();
+          }
+
+
+	}
+
+
+
+        Provenance getVamsasProvenance(jalview.datamodel.Provenance jprov)
+        {
+          jalview.datamodel.ProvenanceEntry [] entries = null;
+
+
+          Provenance prov = new Provenance();
+          org.exolab.castor.types.Date date = new org.exolab.castor.types.Date(
+      new java.util.Date());
+          Entry provEntry;
+
+          if(jprov!=null)
+          {
+            entries = jprov.getEntries();
+            for (int i = 0; i < entries.length; i++)
+            {
+              provEntry = new Entry();
+              try
+              {
+                date = new org.exolab.castor.types.Date(entries[i].getDate());
+              }
+              catch (Exception ex)
+              {
+                ex.printStackTrace();
+
+                date = new org.exolab.castor.types.Date(entries[i].getDate());
+              }
+              provEntry.setDate(date);
+              provEntry.setUser(entries[i].getUser());
+              provEntry.setAction(entries[i].getAction());
+              prov.addEntry(provEntry);
+            }
+          }
+          else
+          {
+            provEntry = new Entry();
+            provEntry.setDate(date);
+            provEntry.setUser(System.getProperty("user.name"));
+            provEntry.setAction("Jalview");
+            prov.addEntry(provEntry);
+          }
+
+          return prov;
+        }
+
+        jalview.datamodel.Provenance getJalviewProvenance(Provenance prov)
+        {
+
+          jalview.datamodel.Provenance jprov = new jalview.datamodel.Provenance();
+          for (int i = 0; i < prov.getEntryCount(); i++)
+          {
+            jprov.addEntry(
+                prov.getEntry(i).getUser(),
+                prov.getEntry(i).getAction(),
+                prov.getEntry(i).getDate().toDate(),
+                prov.getEntry(i).getId()
+                );
+          }
+
+          return jprov;
+        }
+
+        Provenance dummyProvenance()
+        {
+          Provenance prov = new Provenance();
+          Entry entry = new Entry();
+          entry.setAction("Jalview");
+          entry.setDate(new org.exolab.castor.types.Date(new java.util.Date()));
+          entry.setUser(System.getProperty("user.name"));
+          prov.addEntry(entry);
+          return prov;
+        }
+
+}
diff --git a/src/jalview/jbgui/GDesktop.java b/src/jalview/jbgui/GDesktop.java
index 63f1836..4ecf779 100755
--- a/src/jalview/jbgui/GDesktop.java
+++ b/src/jalview/jbgui/GDesktop.java
@@ -48,8 +48,9 @@ public class GDesktop extends JFrame
     JMenuItem saveState = new JMenuItem();
     JMenuItem loadState = new JMenuItem();
     JMenu jMenu1 = new JMenu();
-  JMenuItem vamsasLoad = new JMenuItem();
+  protected JMenuItem vamsasLoad = new JMenuItem();
   JMenuItem inputSequence = new JMenuItem();
+  protected JMenuItem vamsasStop = new JMenuItem();
 
   /**
      * Creates a new GDesktop object.
@@ -160,8 +161,8 @@ public class GDesktop extends JFrame
             });
         jMenu1.setMnemonic('I');
         jMenu1.setText("Input Alignment");
-    vamsasLoad.setText("Vamsas");
-    vamsasLoad.setVisible(false);
+    vamsasLoad.setText("Start Vamsas Session...");
+    vamsasLoad.setVisible(true);
     vamsasLoad.addActionListener(new ActionListener()
     {
       public void actionPerformed(ActionEvent e)
@@ -177,7 +178,15 @@ public class GDesktop extends JFrame
         inputSequence_actionPerformed(e);
       }
     });
-    DesktopMenubar.add(FileMenu);
+    vamsasStop.setText("Stop Vamsas Session");
+    vamsasStop.setVisible(false);
+    vamsasStop.addActionListener(new ActionListener()
+    {
+      public void actionPerformed(ActionEvent e)
+      {
+        vamsasStop_actionPerformed(e);
+      }
+    });    DesktopMenubar.add(FileMenu);
         DesktopMenubar.add(toolsMenu);
         DesktopMenubar.add(HelpMenu);
         DesktopMenubar.add(windowMenu);
@@ -188,15 +197,17 @@ public class GDesktop extends JFrame
         FileMenu.add(saveState);
         FileMenu.add(loadState);
         FileMenu.addSeparator();
-        FileMenu.add(quit);
+        FileMenu.add(vamsasLoad);
+        FileMenu.add(vamsasStop);
+    FileMenu.addSeparator();
+    FileMenu.add(quit);
         HelpMenu.add(aboutMenuItem);
         HelpMenu.add(documentationMenuItem);
         toolsMenu.add(preferences);
         jMenu1.add(inputLocalFileMenuItem);
         jMenu1.add(inputURLMenuItem);
         jMenu1.add(inputTextboxMenuItem);
-    jMenu1.add(vamsasLoad);
-  }
+      }
 
     /**
      * DOCUMENT ME!
@@ -304,4 +315,8 @@ public class GDesktop extends JFrame
   {
 
   }
+  public void vamsasStop_actionPerformed(ActionEvent e)
+  {
+
+  }
 }