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