Clover icon

jalviewX

  1. Project Clover database Wed Oct 31 2018 15:13:58 GMT
  2. Package jalview.gui

File VamsasApplication.java

 

Coverage histogram

../../img/srcFileCovDistChart0.png
56% of files have more coverage

Code metrics

162
365
33
1
1,128
873
143
0.39
11.06
33
4.33

Classes

Class Line # Actions
VamsasApplication 68 365 143 560
0.00%
 

Contributing tests

No tests hitting this source file were found.

Source view

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