JAL-1863 allow RNA secondary structure rows exported by Jalview to be imported again
[jalview.git] / src / jalview / gui / VamsasApplication.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.gui;
22
23 import jalview.bin.Cache;
24 import jalview.datamodel.AlignmentI;
25 import jalview.datamodel.ColumnSelection;
26 import jalview.datamodel.SequenceGroup;
27 import jalview.datamodel.SequenceI;
28 import jalview.io.VamsasAppDatastore;
29 import jalview.structure.SelectionListener;
30 import jalview.structure.SelectionSource;
31 import jalview.structure.StructureSelectionManager;
32 import jalview.structure.VamsasListener;
33 import jalview.structure.VamsasSource;
34 import jalview.util.MessageManager;
35 import jalview.viewmodel.AlignmentViewport;
36
37 import java.beans.PropertyChangeEvent;
38 import java.beans.PropertyChangeListener;
39 import java.io.File;
40 import java.io.IOException;
41 import java.util.Hashtable;
42 import java.util.IdentityHashMap;
43 import java.util.Iterator;
44
45 import javax.swing.JInternalFrame;
46 import javax.swing.JOptionPane;
47
48 import uk.ac.vamsas.client.ClientHandle;
49 import uk.ac.vamsas.client.IClient;
50 import uk.ac.vamsas.client.IClientDocument;
51 import uk.ac.vamsas.client.InvalidSessionDocumentException;
52 import uk.ac.vamsas.client.UserHandle;
53 import uk.ac.vamsas.client.VorbaId;
54 import uk.ac.vamsas.client.picking.IMessageHandler;
55 import uk.ac.vamsas.client.picking.IPickManager;
56 import uk.ac.vamsas.client.picking.Message;
57 import uk.ac.vamsas.client.picking.MouseOverMessage;
58 import uk.ac.vamsas.client.picking.SelectionMessage;
59 import uk.ac.vamsas.objects.core.Entry;
60 import uk.ac.vamsas.objects.core.Input;
61 import uk.ac.vamsas.objects.core.Pos;
62 import uk.ac.vamsas.objects.core.Seg;
63
64 /**
65  * @author jimp
66  * 
67  */
68 public class VamsasApplication implements SelectionSource, VamsasSource
69 {
70   IClient vclient = null;
71
72   ClientHandle app = null;
73
74   UserHandle user = null;
75
76   Desktop jdesktop = null; // our jalview desktop reference
77
78   private boolean inInitialUpdate = true;
79
80   // Cache.preferences for vamsas client session arena
81   // preferences for check for default session at startup.
82   // user and organisation stuff.
83   public VamsasApplication(Desktop jdesktop, File sessionPath,
84           String sessionName)
85   {
86     // JBPNote:
87     // we should create a session URI from the sessionPath and pass it to
88     // the clientFactory - but the vamsas api doesn't cope with that yet.
89     this.jdesktop = jdesktop;
90     initClientSession(null, sessionPath, sessionName);
91   }
92
93   private static uk.ac.vamsas.client.IClientFactory getClientFactory()
94           throws IOException
95   {
96     return new uk.ac.vamsas.client.simpleclient.SimpleClientFactory();
97   }
98
99   /**
100    * Start a new vamsas session
101    * 
102    * @param jdesktop
103    */
104   public VamsasApplication(Desktop jdesktop)
105   {
106     this.jdesktop = jdesktop;
107     initClientSession(null, null);
108   }
109
110   /**
111    * init a connection to the session at the given url
112    * 
113    * @param jdesktop
114    * @param sessionUrl
115    */
116   public VamsasApplication(Desktop jdesktop, String sessionUrl)
117   {
118     this.jdesktop = jdesktop;
119     initClientSession(sessionUrl, null);
120   }
121
122   /**
123    * @throws IOException
124    *           or other if clientfactory instantiation failed.
125    * @return list of current sessions or null if no session exists.
126    */
127   public static String[] getSessionList() throws Exception
128   {
129     return getClientFactory().getCurrentSessions();
130   }
131
132   /**
133    * initialise, possibly with either a valid session url or a file for a new
134    * session
135    * 
136    * @param sess
137    *          null or a valid session url
138    * @param vamsasDocument
139    *          null or a valid vamsas document file
140    * @return false if no vamsas connection was made
141    */
142   private void initClientSession(String sess, File vamsasDocument)
143   {
144     initClientSession(sess, vamsasDocument, null);
145   }
146
147   private boolean initClientSession(String sess, File vamsasDocument,
148           String newDocSessionName)
149   {
150     try
151     {
152       // Only need to tell the library what the application is here
153       app = getJalviewHandle();
154       uk.ac.vamsas.client.IClientFactory clientfactory = getClientFactory();
155       if (vamsasDocument != null)
156       {
157         if (sess != null)
158         {
159           throw new Error(MessageManager.getString("error.implementation_error_cannot_import_vamsas_doc"));
160         }
161         try
162         {
163           if (newDocSessionName != null)
164           {
165             vclient = clientfactory.openAsNewSessionIClient(app,
166                     vamsasDocument, newDocSessionName);
167           }
168           else
169           {
170             vclient = clientfactory.openAsNewSessionIClient(app,
171                     vamsasDocument);
172           }
173         } catch (InvalidSessionDocumentException e)
174         {
175           JOptionPane
176                   .showInternalMessageDialog(
177                           Desktop.desktop,
178
179                           MessageManager.getString("label.vamsas_doc_couldnt_be_opened_as_new_session"),
180                           MessageManager.getString("label.vamsas_document_import_failed"),
181                           JOptionPane.ERROR_MESSAGE);
182
183         }
184       }
185       else
186       {
187         // join existing or create a new session
188         if (sess == null)
189         {
190           vclient = clientfactory.getNewSessionIClient(app);
191         }
192         else
193         {
194           vclient = clientfactory.getIClient(app, sess);
195         }
196       }
197       // set some properties for our VAMSAS interaction
198       setVclientConfig();
199       user = vclient.getUserHandle();
200
201     } catch (Exception e)
202     {
203       jalview.bin.Cache.log
204               .error("Couldn't instantiate vamsas client !", e);
205       return false;
206     }
207     return true;
208   }
209
210   private void setVclientConfig()
211   {
212     if (vclient == null)
213     {
214       return;
215     }
216     try
217     {
218       if (vclient instanceof uk.ac.vamsas.client.simpleclient.SimpleClient)
219       {
220         uk.ac.vamsas.client.simpleclient.SimpleClientConfig cfg = ((uk.ac.vamsas.client.simpleclient.SimpleClient) vclient)
221                 .getSimpleClientConfig();
222         cfg._validatemergedroots = false;
223         cfg._validateupdatedroots = true; // we may write rubbish otherwise.
224       }
225     } catch (Error e)
226     {
227       Cache.log
228               .warn("Probable SERIOUS VAMSAS client incompatibility - carrying on regardless",
229                       e);
230     } catch (Exception e)
231     {
232       Cache.log
233               .warn("Probable VAMSAS client incompatibility - carrying on regardless",
234                       e);
235     }
236   }
237
238   /**
239    * make the appHandle for Jalview
240    * 
241    * @return
242    */
243   private ClientHandle getJalviewHandle()
244   {
245     return new ClientHandle("jalview.bin.Jalview",
246             jalview.bin.Cache.getProperty("VERSION"));
247   }
248
249   /**
250    * 
251    * @return true if we are registered in a vamsas session
252    */
253   public boolean inSession()
254   {
255     return (vclient != null);
256   }
257
258   /**
259    * called to connect to session inits handlers, does an initial document
260    * update.
261    */
262   public void initial_update()
263   {
264     if (!inSession())
265     {
266       throw new Error(MessageManager.getString("error.implementation_error_vamsas_operation_not_init"));
267     }
268     addDocumentUpdateHandler();
269     addStoreDocumentHandler();
270     startSession();
271     inInitialUpdate = true;
272     Cache.log
273             .debug("Jalview loading the Vamsas Session for the first time.");
274     dealWithDocumentUpdate(false); // we don't push an update out to the
275     inInitialUpdate = false;
276     // document yet.
277     Cache.log.debug("... finished update for the first time.");
278   }
279
280   /**
281    * Update all windows after a vamsas datamodel change. this could go on the
282    * desktop object!
283    * 
284    */
285   protected void updateJalviewGui()
286   {
287     JInternalFrame[] frames = jdesktop.getAllFrames();
288
289     if (frames == null)
290     {
291       return;
292     }
293
294     try
295     {
296       // REVERSE ORDER
297       for (int i = frames.length - 1; i > -1; i--)
298       {
299         if (frames[i] instanceof AlignFrame)
300         {
301           AlignFrame af = (AlignFrame) frames[i];
302           af.alignPanel.alignmentChanged();
303         }
304       }
305     } catch (Exception e)
306     {
307       Cache.log
308               .warn("Exception whilst refreshing jalview windows after a vamsas document update.",
309                       e);
310     }
311   }
312
313   public void push_update()
314   {
315     Thread udthread = new Thread(new Runnable()
316     {
317
318       public void run()
319       {
320         Cache.log.info("Jalview updating to the Vamsas Session.");
321
322         dealWithDocumentUpdate(true);
323         Cache.log.info("Jalview finished updating to the Vamsas Session.");
324       }
325
326     });
327     udthread.start();
328   }
329
330   /**
331    * leave a session, prompting the user to save if necessary
332    */
333   public void end_session()
334   {
335     end_session(true);
336   }
337
338   private boolean promptUser = true;
339
340   /**
341    * leave a session, optionally prompting the user to save if necessary
342    * 
343    * @param promptUser
344    *          when true enable prompting by this application
345    */
346
347   public void end_session(boolean promptUser)
348   {
349     if (!inSession())
350     {
351       throw new Error(MessageManager.getString("error.jalview_no_connected_vamsas_session"));
352     }
353     Cache.log.info("Jalview disconnecting from the Vamsas Session.");
354     try
355     {
356       if (joinedSession)
357       {
358         boolean ourprompt = this.promptUser;
359         this.promptUser = promptUser;
360         vclient.finalizeClient();
361         Cache.log.info("Jalview has left the session.");
362         this.promptUser = ourprompt; // restore default value
363       }
364       else
365       {
366         Cache.log
367                 .warn("JV Client leaving a session that's its not joined yet.");
368       }
369       joinedSession = false;
370       vclient = null;
371       app = null;
372       user = null;
373       jv2vobj = null;
374       vobj2jv = null;
375     } catch (Exception e)
376     {
377       Cache.log.error("Vamsas Session finalization threw exceptions!", e);
378     }
379   }
380
381   public void updateJalview(IClientDocument cdoc)
382   {
383     Cache.log.debug("Jalview updating from sesion document ..");
384     ensureJvVamsas();
385     VamsasAppDatastore vds = new VamsasAppDatastore(cdoc, vobj2jv, jv2vobj,
386             baseProvEntry(), alRedoState);
387     try
388     {
389       vds.updateToJalview();
390     } catch (Exception e)
391     {
392       Cache.log.error("Failed to update Jalview from vamsas document.", e);
393     }
394     try
395     {
396       if (firstUpdate)
397       {
398         vds.updateJalviewFromAppdata();
399         // Comment this out to repeatedly read in data from JalviewAppData
400         // firstUpdate=false;
401       }
402     } catch (Exception e)
403     {
404       Cache.log.error(
405               "Exception when updating Jalview settings from Appdata.", e);
406     }
407     Cache.log.debug(".. finished updating from sesion document.");
408
409   }
410
411   boolean firstUpdate = false;
412
413   private void ensureJvVamsas()
414   {
415     if (jv2vobj == null)
416     {
417       jv2vobj = new IdentityHashMap();
418       vobj2jv = new Hashtable();
419       alRedoState = new Hashtable();
420       firstUpdate = true;
421     }
422   }
423
424   /**
425    * jalview object binding to VorbaIds
426    */
427   IdentityHashMap jv2vobj = null;
428
429   Hashtable vobj2jv = null;
430
431   Hashtable alRedoState = null;
432
433   boolean errorsDuringUpdate = false;
434
435   boolean errorsDuringAppUpdate = false;
436
437   /**
438    * update the document accessed through doc. A backup of the current object
439    * bindings is made.
440    * 
441    * @param doc
442    * @return number of views stored in document (updated and new views)
443    */
444   public int updateVamsasDocument(IClientDocument doc)
445   {
446     int storedviews = 0;
447     ensureJvVamsas();
448     errorsDuringUpdate = false;
449     errorsDuringAppUpdate = false;
450     backup_objectMapping();
451     VamsasAppDatastore vds = new VamsasAppDatastore(doc, vobj2jv, jv2vobj,
452             baseProvEntry(), alRedoState);
453     // wander through frames
454     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
455
456     if (frames == null)
457     {
458       return 0;
459     }
460     Hashtable skipList = new Hashtable();
461     Hashtable viewset = new Hashtable();
462
463     try
464     {
465       // REVERSE ORDER
466       for (int i = frames.length - 1; i > -1; i--)
467       {
468         if (frames[i] instanceof AlignFrame)
469         {
470           AlignFrame af = (AlignFrame) frames[i];
471           if (!viewset.containsKey(af.getViewport().getSequenceSetId()))
472           {
473             // update alignment and root from frame.
474             boolean stored = false;
475             try
476             {
477               stored = vds.storeVAMSAS(af.getViewport(), af.getTitle());
478             } catch (Exception e)
479             {
480               errorsDuringUpdate = true;
481               Cache.log.error("Exception synchronizing "
482                       + af.getTitle()
483                       + " "
484                       + (af.getViewport().viewName == null ? "" : " view "
485                               + af.getViewport().viewName)
486                       + " to document.", e);
487               stored = false;
488             }
489             if (!stored)
490             { // record skip in skipList
491               skipList.put(af.getViewport().getSequenceSetId(), af);
492             }
493             else
494             {
495               storedviews++;
496               // could try to eliminate sequenceSetId from skiplist ..
497               // (skipList.containsKey(af.getViewport().getSequenceSetId()))
498               // remember sequenceSetId so we can skip all the other views on
499               // same alignment
500               viewset.put(af.getViewport().getSequenceSetId(), af);
501             }
502           }
503         }
504       }
505       // REVERSE ORDER
506       // for (int i = frames.length - 1; i > -1; i--)
507       // {
508       // if (frames[i] instanceof AlignFrame)
509       // {
510       // AlignFrame af = (AlignFrame) frames[i];
511       Iterator aframes = viewset.values().iterator();
512       while (aframes.hasNext())
513       {
514         AlignFrame af = (AlignFrame) aframes.next();
515         // add any AlignedCodonFrame mappings on this alignment to any other.
516         vds.storeSequenceMappings(af.getViewport(), af.getTitle());
517       }
518     } catch (Exception e)
519     {
520       Cache.log.error("Exception synchronizing Views to Document :", e);
521       errorsDuringUpdate = true;
522     }
523
524     try
525     {
526       if (viewset.size() > 0)
527       {
528         // Alignment views were synchronized, so store their state in the
529         // appData, too.
530         // The skipList ensures we don't write out any alignments not actually
531         // in the document.
532         vds.setSkipList(skipList);
533         vds.updateJalviewClientAppdata();
534       }
535     } catch (Exception e)
536     {
537       Cache.log.error("Client Appdata Write exception", e);
538       errorsDuringAppUpdate = true;
539     }
540     vds.clearSkipList();
541     return storedviews;
542   }
543
544   private Entry baseProvEntry()
545   {
546     uk.ac.vamsas.objects.core.Entry pentry = new uk.ac.vamsas.objects.core.Entry();
547     pentry.setUser(user.getFullName());
548     pentry.setApp(app.getClientUrn());
549     pentry.setDate(new java.util.Date());
550     pentry.setAction("created");
551     return pentry;
552   }
553
554   /**
555    * do a vamsas document update or update jalview from the vamsas document
556    * 
557    * @param fromJalview
558    *          true to update from jalview to the vamsas document
559    * @return total number of stored alignments in the document after the update
560    */
561   protected int dealWithDocumentUpdate(boolean fromJalview)
562   {
563     int storedviews = 0;
564     // called by update handler for document update.
565     Cache.log.debug("Updating jalview from changed vamsas document.");
566     disableGui(true);
567     try
568     {
569       long time = System.currentTimeMillis();
570       IClientDocument cdoc = vclient.getClientDocument();
571       if (Cache.log.isDebugEnabled())
572       {
573         Cache.log.debug("Time taken to get ClientDocument = "
574                 + (System.currentTimeMillis() - time));
575         time = System.currentTimeMillis();
576       }
577       if (fromJalview)
578       {
579         storedviews += updateVamsasDocument(cdoc);
580         if (Cache.log.isDebugEnabled())
581         {
582           Cache.log
583                   .debug("Time taken to update Vamsas Document from jalview\t= "
584                           + (System.currentTimeMillis() - time));
585           time = System.currentTimeMillis();
586         }
587         cdoc.setVamsasRoots(cdoc.getVamsasRoots());
588         if (Cache.log.isDebugEnabled())
589         {
590           Cache.log.debug("Time taken to set Document Roots\t\t= "
591                   + (System.currentTimeMillis() - time));
592           time = System.currentTimeMillis();
593         }
594       }
595       else
596       {
597         updateJalview(cdoc);
598         if (Cache.log.isDebugEnabled())
599         {
600           Cache.log
601                   .debug("Time taken to update Jalview from vamsas document Roots\t= "
602                           + (System.currentTimeMillis() - time));
603           time = System.currentTimeMillis();
604         }
605
606       }
607       vclient.updateDocument(cdoc);
608       if (Cache.log.isDebugEnabled())
609       {
610         Cache.log.debug("Time taken to update Session Document\t= "
611                 + (System.currentTimeMillis() - time));
612         time = System.currentTimeMillis();
613       }
614       cdoc = null;
615     } catch (Exception ee)
616     {
617       System.err.println("Exception whilst updating :");
618       ee.printStackTrace(System.err);
619       // recover object map backup, since its probably corrupted with references
620       // to Vobjects that don't exist anymore.
621       recover_objectMappingBackup();
622       storedviews = 0;
623     }
624     Cache.log.debug("Finished updating from document change.");
625     disableGui(false);
626     return storedviews;
627   }
628
629   private void addDocumentUpdateHandler()
630   {
631     final VamsasApplication client = this;
632     vclient.addDocumentUpdateHandler(new PropertyChangeListener()
633     {
634       public void propertyChange(PropertyChangeEvent evt)
635       {
636         Cache.log.debug("Dealing with document update event.");
637         client.dealWithDocumentUpdate(false);
638         Cache.log.debug("finished dealing with event.");
639       }
640     });
641     Cache.log.debug("Added Jalview handler for vamsas document updates.");
642   }
643
644   private void addStoreDocumentHandler()
645   {
646     final VamsasApplication client = this;
647     vclient.addVorbaEventHandler(
648             uk.ac.vamsas.client.Events.DOCUMENT_REQUESTTOCLOSE,
649             new PropertyChangeListener()
650             {
651               public void propertyChange(PropertyChangeEvent evt)
652               {
653                 if (client.promptUser)
654                 {
655                   Cache.log
656                           .debug("Asking user if the vamsas session should be stored.");
657                   int reply = JOptionPane
658                           .showInternalConfirmDialog(
659                                   Desktop.desktop,
660                                   "The current VAMSAS session has unsaved data - do you want to save it ?",
661                                   "VAMSAS Session Shutdown",
662                                   JOptionPane.YES_NO_OPTION,
663                                   JOptionPane.QUESTION_MESSAGE);
664
665                   if (reply == JOptionPane.YES_OPTION)
666                   {
667                     Cache.log.debug("Prompting for vamsas store filename.");
668                     Desktop.instance.vamsasSave_actionPerformed(null);
669                     Cache.log
670                             .debug("Finished attempt at storing document.");
671                   }
672                   Cache.log
673                           .debug("finished dealing with REQUESTTOCLOSE event.");
674                 }
675                 else
676                 {
677                   Cache.log
678                           .debug("Ignoring store document request (promptUser==false)");
679                 }
680               }
681             });
682     Cache.log.debug("Added Jalview handler for vamsas document updates.");
683   }
684
685   public void disableGui(boolean b)
686   {
687     Desktop.instance.setVamsasUpdate(b);
688   }
689
690   Hashtable _backup_vobj2jv;
691
692   IdentityHashMap _backup_jv2vobj;
693
694   /**
695    * make a backup of the object mappings (vobj2jv and jv2vobj)
696    */
697   public void backup_objectMapping()
698   {
699     _backup_vobj2jv = new Hashtable(vobj2jv);
700     _backup_jv2vobj = new IdentityHashMap(jv2vobj);
701   }
702
703   /**
704    * recover original object mappings from the object mapping backup if document
705    * IO failed
706    * 
707    * @throws Error
708    *           if backup_objectMapping was not called.
709    */
710   public void recover_objectMappingBackup()
711   {
712     if (_backup_vobj2jv == null)
713     {
714       if (inInitialUpdate)
715       {
716         // nothing to recover so just
717         return;
718       }
719
720       throw new Error(MessageManager.getString("error.implementation_error_cannot_recover_vamsas_object_mappings"));
721     }
722     jv2vobj.clear();
723     Iterator el = _backup_jv2vobj.entrySet().iterator();
724     while (el.hasNext())
725     {
726       java.util.Map.Entry mp = (java.util.Map.Entry) el.next();
727       jv2vobj.put(mp.getKey(), mp.getValue());
728     }
729     el = _backup_vobj2jv.entrySet().iterator();
730     while (el.hasNext())
731     {
732       java.util.Map.Entry mp = (java.util.Map.Entry) el.next();
733       vobj2jv.put(mp.getKey(), mp.getValue());
734     }
735   }
736
737   private boolean joinedSession = false;
738
739   private VamsasListener picker = null;
740
741   private SelectionListener selecter;
742
743   private void startSession()
744   {
745     if (inSession())
746     {
747       try
748       {
749         vclient.joinSession();
750         joinedSession = true;
751       } catch (Exception e)
752       {
753         // Complain to GUI
754         Cache.log.error("Failed to join vamsas session.", e);
755         vclient = null;
756       }
757       try
758       {
759         final IPickManager pm = vclient.getPickManager();
760         final StructureSelectionManager ssm = StructureSelectionManager
761                 .getStructureSelectionManager(Desktop.instance);
762         final VamsasApplication me = this;
763         pm.registerMessageHandler(new IMessageHandler()
764         {
765           String last = null;
766
767           public void handleMessage(Message message)
768           {
769             if (vobj2jv == null)
770             {
771               // we are not in a session yet.
772               return;
773             }
774             if (message instanceof MouseOverMessage)
775             {
776               MouseOverMessage mm = (MouseOverMessage) message;
777               String mstring = mm.getVorbaID() + " " + mm.getPosition();
778               if (last != null && mstring.equals(last))
779               {
780                 return;
781               }
782               // if (Cache.log.isDebugEnabled())
783               // {
784               // Cache.log.debug("Received MouseOverMessage "+mm.getVorbaID()+"
785               // "+mm.getPosition());
786               // }
787               Object jvobj = vobj2jv.get(mm.getVorbaID());
788               if (jvobj != null && jvobj instanceof SequenceI)
789               {
790                 last = mstring;
791                 // Cache.log.debug("Handling Mouse over "+mm.getVorbaID()+"
792                 // bound to "+jvobj+" at "+mm.getPosition());
793                 // position is character position in aligned sequence
794                 ssm.mouseOverVamsasSequence((SequenceI) jvobj,
795                         mm.getPosition(), me);
796               }
797             }
798             if (message instanceof uk.ac.vamsas.client.picking.SelectionMessage)
799             {
800               // we only care about AlignmentSequence selections
801               SelectionMessage sm = (SelectionMessage) message;
802               sm.validate();
803               System.err.println("Received\n" + sm.getRawMessage());
804               Object[] jvobjs = sm.getVorbaIDs() == null ? null
805                       : new Object[sm.getVorbaIDs().length];
806               if (jvobjs == null)
807               {
808                 // TODO: rationalise : can only clear a selection over a
809                 // referred to object
810                 ssm.sendSelection(null, null, me);
811                 return;
812               }
813               Class type = null;
814               boolean send = true;
815               for (int o = 0; o < jvobjs.length; o++)
816               {
817                 jvobjs[o] = vobj2jv.get(sm.getVorbaIDs()[o]);
818                 if (jvobjs[o] == null)
819                 {
820                   // can't cope with selections for unmapped objects
821                   continue;
822                 }
823                 if (type == null)
824                 {
825                   type = jvobjs[o].getClass();
826                 }
827                 ;
828                 if (type != jvobjs[o].getClass())
829                 {
830                   send = false;
831                   // discard - can't cope with selections over mixed objects
832                   // continue;
833                 }
834               }
835               SequenceGroup jselection = null;
836               ColumnSelection colsel = null;
837               if (type == jalview.datamodel.Alignment.class)
838               {
839                 if (jvobjs.length == 1)
840                 {
841                   // TODO if (sm.isNone())// send a message to select the
842                   // specified columns over the
843                   // given
844                   // alignment
845
846                   send = true;
847                 }
848               }
849               if (type == jalview.datamodel.Sequence.class)
850               {
851
852                 SequenceI seq;
853                 boolean aligned = ((jalview.datamodel.Sequence) jvobjs[0])
854                         .getDatasetSequence() != null;
855                 int maxWidth = 0;
856                 if (aligned)
857                 {
858                   jselection = new SequenceGroup();
859                   jselection.addSequence(
860                           seq = (jalview.datamodel.Sequence) jvobjs[0],
861                           false);
862                   maxWidth = seq.getLength();
863                 }
864                 for (int c = 1; aligned && jvobjs.length > 1
865                         && c < jvobjs.length; c++)
866                 {
867                   if (((jalview.datamodel.Sequence) jvobjs[c])
868                           .getDatasetSequence() == null)
869                   {
870                     aligned = false;
871                     continue;
872                   }
873                   else
874                   {
875                     jselection.addSequence(
876                             seq = (jalview.datamodel.Sequence) jvobjs[c],
877                             false);
878                     if (maxWidth < seq.getLength())
879                     {
880                       maxWidth = seq.getLength();
881                     }
882
883                   }
884                 }
885                 if (!aligned)
886                 {
887                   jselection = null;
888                   // if cardinality is greater than one then verify all
889                   // sequences are alignment sequences.
890                   if (jvobjs.length == 1)
891                   {
892                     // find all instances of this dataset sequence in the
893                     // displayed alignments containing the associated range and
894                     // select them.
895                   }
896                 }
897                 else
898                 {
899                   jselection.setStartRes(0);
900                   jselection.setEndRes(maxWidth);
901                   // locate the alignment containing the given sequences and
902                   // select the associated ranges on them.
903                   if (sm.getRanges() != null)
904                   {
905                     int[] prange = uk.ac.vamsas.objects.utils.Range
906                             .getBounds(sm.getRanges());
907                     jselection.setStartRes(prange[0] - 1);
908                     jselection.setEndRes(prange[1] - 1);
909                     prange = uk.ac.vamsas.objects.utils.Range
910                             .getIntervals(sm.getRanges());
911                     colsel = new ColumnSelection();
912                     for (int p = 0; p < prange.length; p += 2)
913                     {
914                       int d = (prange[p] <= prange[p + 1]) ? 1 : -1;
915                       // try to join up adjacent columns to make a larger
916                       // selection
917                       // lower and upper bounds
918                       int l = (d < 0) ? 1 : 0;
919                       int u = (d > 0) ? 1 : 0;
920
921                       if (jselection.getStartRes() > 0
922                               && prange[p + l] == jselection.getStartRes())
923                       {
924                         jselection.setStartRes(prange[p + l] - 1);
925                       }
926                       if (jselection.getEndRes() <= maxWidth
927                               && prange[p + u] == (jselection.getEndRes() + 2))
928                       {
929                         jselection.setEndRes(prange[p + u] - 1);
930                       }
931                       // mark all the columns in the range.
932                       for (int sr = prange[p], er = prange[p + 1], de = er
933                               + d; sr != de; sr += d)
934                       {
935                         colsel.addElement(sr - 1);
936                       }
937                     }
938                   }
939                   send = true;
940                 }
941               }
942               if (send)
943               {
944                 ssm.sendSelection(jselection, colsel, me);
945               }
946               // discard message.
947               for (int c = 0; c < jvobjs.length; c++)
948               {
949                 jvobjs[c] = null;
950               }
951               ;
952               jvobjs = null;
953               return;
954             }
955           }
956         });
957         picker = new VamsasListener()
958         {
959           SequenceI last = null;
960
961           int i = -1;
962
963           @Override
964           public void mouseOverSequence(SequenceI seq, int index,
965                   VamsasSource source)
966           {
967             if (jv2vobj == null)
968             {
969               return;
970             }
971             if (seq != last || i != index)
972             {
973               VorbaId v = (VorbaId) jv2vobj.get(seq);
974               if (v != null)
975               {
976                 // this should really be a trace message.
977                 // Cache.log.debug("Mouse over " + v.getId() + " bound to "
978                 // + seq + " at " + index);
979                 last = seq;
980                 i = index;
981                 MouseOverMessage message = new MouseOverMessage(v.getId(),
982                         index);
983                 pm.sendMessage(message);
984               }
985             }
986           }
987         };
988         selecter = new SelectionListener()
989         {
990
991           public void selection(SequenceGroup seqsel,
992                   ColumnSelection colsel, SelectionSource source)
993           {
994             if (vobj2jv == null)
995             {
996               Cache.log
997                       .warn("Selection listener still active for dead session.");
998               // not in a session.
999               return;
1000             }
1001             if (source != me)
1002             {
1003               AlignmentI visal = null;
1004               if (source instanceof AlignViewport)
1005               {
1006                 visal = ((AlignmentViewport) source).getAlignment();
1007               }
1008               SelectionMessage sm = null;
1009               if ((seqsel == null || seqsel.getSize() == 0)
1010                       && (colsel == null || colsel.getSelected() == null || colsel
1011                               .getSelected().size() == 0))
1012               {
1013                 if (source instanceof AlignViewport)
1014                 {
1015                   // the empty selection.
1016                   sm = new SelectionMessage("jalview", new String[]
1017                   { ((AlignmentViewport) source).getSequenceSetId() }, null,
1018                           true);
1019                 }
1020                 else
1021                 {
1022                   // the empty selection.
1023                   sm = new SelectionMessage("jalview", null, null, true);
1024                 }
1025               }
1026               else
1027               {
1028                 String[] vobj = new String[seqsel.getSize()];
1029                 int o = 0;
1030                 for (SequenceI sel : seqsel.getSequences(null))
1031                 {
1032                   VorbaId v = (VorbaId) jv2vobj.get(sel);
1033                   if (v != null)
1034                   {
1035                     vobj[o++] = v.toString();
1036                   }
1037                 }
1038                 if (o < vobj.length)
1039                 {
1040                   String t[] = vobj;
1041                   vobj = new String[o];
1042                   System.arraycopy(t, 0, vobj, 0, o);
1043                   t = null;
1044                 }
1045                 Input range = null;
1046                 if (seqsel != null && colsel != null)
1047                 {
1048                   // deparse the colsel into positions on the vamsas alignment
1049                   // sequences
1050                   range = new Input();
1051                   if (colsel.getSelected() != null
1052                           && colsel.getSelected().size() > 0
1053                           && visal != null
1054                           && seqsel.getSize() == visal.getHeight())
1055                   {
1056                     // gather selected columns outwith the sequence positions
1057                     // too
1058                     for (Object obj : colsel.getSelected())
1059                     {
1060                       int ival = ((Integer) obj).intValue();
1061                       Pos p = new Pos();
1062                       p.setI(ival + 1);
1063                       range.addPos(p);
1064                     }
1065                   }
1066                   else
1067                   {
1068                     int[] intervals = colsel.getVisibleContigs(
1069                             seqsel.getStartRes(), seqsel.getEndRes() + 1);
1070                     for (int iv = 0; iv < intervals.length; iv += 2)
1071                     {
1072                       Seg s = new Seg();
1073                       s.setStart(intervals[iv] + 1); // vamsas indices begin at
1074                       // 1, not zero.
1075                       s.setEnd(intervals[iv + 1] + 1);
1076                       s.setInclusive(true);
1077                       range.addSeg(s);
1078                     }
1079                   }
1080                 }
1081                 if (vobj.length > 0)
1082                 {
1083                   sm = new SelectionMessage("jalview", vobj, range);
1084                 }
1085                 else
1086                 {
1087                   sm = null;
1088                 }
1089               }
1090               if (sm != null)
1091               {
1092                 sm.validate(); // debug
1093                 Cache.log.debug("Selection Message\n" + sm.getRawMessage());
1094                 pm.sendMessage(sm);
1095               }
1096             }
1097           }
1098
1099         };
1100         ssm.addStructureViewerListener(picker); // better method here
1101         ssm.addSelectionListener(selecter);
1102       } catch (Exception e)
1103       {
1104         Cache.log.error("Failed to init Vamsas Picking", e);
1105       }
1106     }
1107   }
1108
1109   public String getCurrentSession()
1110   {
1111     if (vclient != null)
1112     {
1113       return (vclient.getSessionUrn());
1114     }
1115     return null;
1116   }
1117 }