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