Merge branch 'features/JAL-2446NCList' into features/JAL-2574findFeaturesByColumn
[jalview.git] / src / jalview / bin / JalviewLite.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.bin;
22
23 import jalview.analysis.AlignmentUtils;
24 import jalview.api.StructureSelectionManagerProvider;
25 import jalview.appletgui.AlignFrame;
26 import jalview.appletgui.AlignViewport;
27 import jalview.appletgui.EmbmenuFrame;
28 import jalview.appletgui.FeatureSettings;
29 import jalview.appletgui.SplitFrame;
30 import jalview.datamodel.Alignment;
31 import jalview.datamodel.AlignmentI;
32 import jalview.datamodel.AlignmentOrder;
33 import jalview.datamodel.ColumnSelection;
34 import jalview.datamodel.HiddenColumns;
35 import jalview.datamodel.PDBEntry;
36 import jalview.datamodel.Sequence;
37 import jalview.datamodel.SequenceGroup;
38 import jalview.datamodel.SequenceI;
39 import jalview.io.AnnotationFile;
40 import jalview.io.AppletFormatAdapter;
41 import jalview.io.DataSourceType;
42 import jalview.io.FileFormatI;
43 import jalview.io.FileFormats;
44 import jalview.io.FileParse;
45 import jalview.io.IdentifyFile;
46 import jalview.io.JPredFile;
47 import jalview.io.JnetAnnotationMaker;
48 import jalview.io.NewickFile;
49 import jalview.javascript.JSFunctionExec;
50 import jalview.javascript.JalviewLiteJsApi;
51 import jalview.javascript.JsCallBack;
52 import jalview.javascript.MouseOverStructureListener;
53 import jalview.structure.SelectionListener;
54 import jalview.structure.StructureSelectionManager;
55 import jalview.util.ColorUtils;
56 import jalview.util.HttpUtils;
57 import jalview.util.MessageManager;
58
59 import java.applet.Applet;
60 import java.awt.Button;
61 import java.awt.Color;
62 import java.awt.Component;
63 import java.awt.EventQueue;
64 import java.awt.Font;
65 import java.awt.Frame;
66 import java.awt.Graphics;
67 import java.awt.event.ActionEvent;
68 import java.awt.event.WindowAdapter;
69 import java.awt.event.WindowEvent;
70 import java.io.BufferedReader;
71 import java.io.IOException;
72 import java.io.InputStreamReader;
73 import java.net.URL;
74 import java.util.ArrayList;
75 import java.util.Hashtable;
76 import java.util.List;
77 import java.util.StringTokenizer;
78 import java.util.Vector;
79
80 import netscape.javascript.JSObject;
81
82 /**
83  * Jalview Applet. Runs in Java 1.18 runtime
84  * 
85  * @author $author$
86  * @version $Revision: 1.92 $
87  */
88 public class JalviewLite extends Applet implements
89         StructureSelectionManagerProvider, JalviewLiteJsApi
90 {
91
92   private static final String TRUE = "true";
93
94   private static final String FALSE = "false";
95
96   public StructureSelectionManager getStructureSelectionManager()
97   {
98     return StructureSelectionManager.getStructureSelectionManager(this);
99   }
100
101   // /////////////////////////////////////////
102   // The following public methods may be called
103   // externally, eg via javascript in HTML page
104   /*
105    * (non-Javadoc)
106    * 
107    * @see jalview.bin.JalviewLiteJsApi#getSelectedSequences()
108    */
109   @Override
110   public String getSelectedSequences()
111   {
112     return getSelectedSequencesFrom(getDefaultTargetFrame());
113   }
114
115   /*
116    * (non-Javadoc)
117    * 
118    * @see jalview.bin.JalviewLiteJsApi#getSelectedSequences(java.lang.String)
119    */
120   @Override
121   public String getSelectedSequences(String sep)
122   {
123     return getSelectedSequencesFrom(getDefaultTargetFrame(), sep);
124   }
125
126   /*
127    * (non-Javadoc)
128    * 
129    * @see
130    * jalview.bin.JalviewLiteJsApi#getSelectedSequencesFrom(jalview.appletgui
131    * .AlignFrame)
132    */
133   @Override
134   public String getSelectedSequencesFrom(AlignFrame alf)
135   {
136     return getSelectedSequencesFrom(alf, separator); // ""+0x00AC);
137   }
138
139   /*
140    * (non-Javadoc)
141    * 
142    * @see
143    * jalview.bin.JalviewLiteJsApi#getSelectedSequencesFrom(jalview.appletgui
144    * .AlignFrame, java.lang.String)
145    */
146   @Override
147   public String getSelectedSequencesFrom(AlignFrame alf, String sep)
148   {
149     StringBuffer result = new StringBuffer("");
150     if (sep == null || sep.length() == 0)
151     {
152       sep = separator; // "+0x00AC;
153     }
154     if (alf.viewport.getSelectionGroup() != null)
155     {
156       SequenceI[] seqs = alf.viewport.getSelectionGroup()
157               .getSequencesInOrder(alf.viewport.getAlignment());
158
159       for (int i = 0; i < seqs.length; i++)
160       {
161         result.append(seqs[i].getName());
162         result.append(sep);
163       }
164     }
165
166     return result.toString();
167   }
168
169   /*
170    * (non-Javadoc)
171    * 
172    * @see jalview.bin.JalviewLiteJsApi#highlight(java.lang.String,
173    * java.lang.String, java.lang.String)
174    */
175   @Override
176   public void highlight(String sequenceId, String position,
177           String alignedPosition)
178   {
179     highlightIn(getDefaultTargetFrame(), sequenceId, position,
180             alignedPosition);
181   }
182
183   /*
184    * (non-Javadoc)
185    * 
186    * @see jalview.bin.JalviewLiteJsApi#highlightIn(jalview.appletgui.AlignFrame,
187    * java.lang.String, java.lang.String, java.lang.String)
188    */
189   @Override
190   public void highlightIn(final AlignFrame alf, final String sequenceId,
191           final String position, final String alignedPosition)
192   {
193     // TODO: could try to highlight in all alignments if alf==null
194     jalview.analysis.SequenceIdMatcher matcher = new jalview.analysis.SequenceIdMatcher(
195             alf.viewport.getAlignment().getSequencesArray());
196     final SequenceI sq = matcher.findIdMatch(sequenceId);
197     if (sq != null)
198     {
199       int apos = -1;
200       try
201       {
202         apos = new Integer(position).intValue();
203         apos--;
204       } catch (NumberFormatException ex)
205       {
206         return;
207       }
208       final StructureSelectionManagerProvider me = this;
209       final int pos = apos;
210       // use vamsas listener to broadcast to all listeners in scope
211       if (alignedPosition != null
212               && (alignedPosition.trim().length() == 0 || alignedPosition
213                       .toLowerCase().indexOf("false") > -1))
214       {
215         java.awt.EventQueue.invokeLater(new Runnable()
216         {
217           @Override
218           public void run()
219           {
220             StructureSelectionManager.getStructureSelectionManager(me)
221                     .mouseOverVamsasSequence(sq, sq.findIndex(pos), null);
222           }
223         });
224       }
225       else
226       {
227         java.awt.EventQueue.invokeLater(new Runnable()
228         {
229           @Override
230           public void run()
231           {
232             StructureSelectionManager.getStructureSelectionManager(me)
233                     .mouseOverVamsasSequence(sq, pos, null);
234           }
235         });
236       }
237     }
238   }
239
240   /*
241    * (non-Javadoc)
242    * 
243    * @see jalview.bin.JalviewLiteJsApi#select(java.lang.String,
244    * java.lang.String)
245    */
246   @Override
247   public void select(String sequenceIds, String columns)
248   {
249     selectIn(getDefaultTargetFrame(), sequenceIds, columns, separator);
250   }
251
252   /*
253    * (non-Javadoc)
254    * 
255    * @see jalview.bin.JalviewLiteJsApi#select(java.lang.String,
256    * java.lang.String, java.lang.String)
257    */
258   @Override
259   public void select(String sequenceIds, String columns, String sep)
260   {
261     selectIn(getDefaultTargetFrame(), sequenceIds, columns, sep);
262   }
263
264   /*
265    * (non-Javadoc)
266    * 
267    * @see jalview.bin.JalviewLiteJsApi#selectIn(jalview.appletgui.AlignFrame,
268    * java.lang.String, java.lang.String)
269    */
270   @Override
271   public void selectIn(AlignFrame alf, String sequenceIds, String columns)
272   {
273     selectIn(alf, sequenceIds, columns, separator);
274   }
275
276   /*
277    * (non-Javadoc)
278    * 
279    * @see jalview.bin.JalviewLiteJsApi#selectIn(jalview.appletgui.AlignFrame,
280    * java.lang.String, java.lang.String, java.lang.String)
281    */
282   @Override
283   public void selectIn(final AlignFrame alf, String sequenceIds,
284           String columns, String sep)
285   {
286     if (sep == null || sep.length() == 0)
287     {
288       sep = separator;
289     }
290     else
291     {
292       if (debug)
293       {
294         System.err.println("Selecting region using separator string '"
295                 + separator + "'");
296       }
297     }
298     // deparse fields
299     String[] ids = separatorListToArray(sequenceIds, sep);
300     String[] cols = separatorListToArray(columns, sep);
301     final SequenceGroup sel = new SequenceGroup();
302     final ColumnSelection csel = new ColumnSelection();
303     AlignmentI al = alf.viewport.getAlignment();
304     jalview.analysis.SequenceIdMatcher matcher = new jalview.analysis.SequenceIdMatcher(
305             alf.viewport.getAlignment().getSequencesArray());
306     int start = 0, end = al.getWidth(), alw = al.getWidth();
307     boolean seqsfound = true;
308     if (ids != null && ids.length > 0)
309     {
310       seqsfound = false;
311       for (int i = 0; i < ids.length; i++)
312       {
313         if (ids[i].trim().length() == 0)
314         {
315           continue;
316         }
317         SequenceI sq = matcher.findIdMatch(ids[i]);
318         if (sq != null)
319         {
320           seqsfound = true;
321           sel.addSequence(sq, false);
322         }
323       }
324     }
325     boolean inseqpos = false;
326     if (cols != null && cols.length > 0)
327     {
328       boolean seset = false;
329       for (int i = 0; i < cols.length; i++)
330       {
331         String cl = cols[i].trim();
332         if (cl.length() == 0)
333         {
334           continue;
335         }
336         int p;
337         if ((p = cl.indexOf("-")) > -1)
338         {
339           int from = -1, to = -1;
340           try
341           {
342             from = new Integer(cl.substring(0, p)).intValue();
343             from--;
344           } catch (NumberFormatException ex)
345           {
346             System.err
347                     .println("ERROR: Couldn't parse first integer in range element column selection string '"
348                             + cl + "' - format is 'from-to'");
349             return;
350           }
351           try
352           {
353             to = new Integer(cl.substring(p + 1)).intValue();
354             to--;
355           } catch (NumberFormatException ex)
356           {
357             System.err
358                     .println("ERROR: Couldn't parse second integer in range element column selection string '"
359                             + cl + "' - format is 'from-to'");
360             return;
361           }
362           if (from >= 0 && to >= 0)
363           {
364             // valid range
365             if (from < to)
366             {
367               int t = to;
368               to = from;
369               to = t;
370             }
371             if (!seset)
372             {
373               start = from;
374               end = to;
375               seset = true;
376             }
377             else
378             {
379               // comment to prevent range extension
380               if (start > from)
381               {
382                 start = from;
383               }
384               if (end < to)
385               {
386                 end = to;
387               }
388             }
389             for (int r = from; r <= to; r++)
390             {
391               if (r >= 0 && r < alw)
392               {
393                 csel.addElement(r);
394               }
395             }
396             if (debug)
397             {
398               System.err.println("Range '" + cl + "' deparsed as [" + from
399                       + "," + to + "]");
400             }
401           }
402           else
403           {
404             System.err.println("ERROR: Invalid Range '" + cl
405                     + "' deparsed as [" + from + "," + to + "]");
406           }
407         }
408         else
409         {
410           int r = -1;
411           try
412           {
413             r = new Integer(cl).intValue();
414             r--;
415           } catch (NumberFormatException ex)
416           {
417             if (cl.toLowerCase().equals("sequence"))
418             {
419               // we are in the dataset sequence's coordinate frame.
420               inseqpos = true;
421             }
422             else
423             {
424               System.err
425                       .println("ERROR: Couldn't parse integer from point selection element of column selection string '"
426                               + cl + "'");
427               return;
428             }
429           }
430           if (r >= 0 && r <= alw)
431           {
432             if (!seset)
433             {
434               start = r;
435               end = r;
436               seset = true;
437             }
438             else
439             {
440               // comment to prevent range extension
441               if (start > r)
442               {
443                 start = r;
444               }
445               if (end < r)
446               {
447                 end = r;
448               }
449             }
450             csel.addElement(r);
451             if (debug)
452             {
453               System.err.println("Point selection '" + cl
454                       + "' deparsed as [" + r + "]");
455             }
456           }
457           else
458           {
459             System.err.println("ERROR: Invalid Point selection '" + cl
460                     + "' deparsed as [" + r + "]");
461           }
462         }
463       }
464     }
465     if (seqsfound)
466     {
467       // we only propagate the selection when it was the null selection, or the
468       // given sequences were found in the alignment.
469       if (inseqpos && sel.getSize() > 0)
470       {
471         // assume first sequence provides reference frame ?
472         SequenceI rs = sel.getSequenceAt(0);
473         start = rs.findIndex(start);
474         end = rs.findIndex(end);
475         List<Integer> cs = new ArrayList<Integer>(csel.getSelected());
476         csel.clear();
477         for (Integer selectedCol : cs)
478         {
479           csel.addElement(rs.findIndex(selectedCol));
480         }
481       }
482       sel.setStartRes(start);
483       sel.setEndRes(end);
484       EventQueue.invokeLater(new Runnable()
485       {
486         @Override
487         public void run()
488         {
489           alf.select(sel, csel, alf.getAlignViewport().getAlignment()
490                   .getHiddenColumns());
491         }
492       });
493     }
494   }
495
496   /*
497    * (non-Javadoc)
498    * 
499    * @see
500    * jalview.bin.JalviewLiteJsApi#getSelectedSequencesAsAlignment(java.lang.
501    * String, java.lang.String)
502    */
503   @Override
504   public String getSelectedSequencesAsAlignment(String format, String suffix)
505   {
506     return getSelectedSequencesAsAlignmentFrom(getDefaultTargetFrame(),
507             format, suffix);
508   }
509
510   /*
511    * (non-Javadoc)
512    * 
513    * @see
514    * jalview.bin.JalviewLiteJsApi#getSelectedSequencesAsAlignmentFrom(jalview
515    * .appletgui.AlignFrame, java.lang.String, java.lang.String)
516    */
517   @Override
518   public String getSelectedSequencesAsAlignmentFrom(AlignFrame alf,
519           String format, String suffix)
520   {
521     try
522     {
523       FileFormatI theFormat = FileFormats.getInstance().forName(format);
524       boolean seqlimits = suffix.equalsIgnoreCase(TRUE);
525       if (alf.viewport.getSelectionGroup() != null)
526       {
527         // JBPNote: getSelectionAsNewSequence behaviour has changed - this
528         // method now returns a full copy of sequence data
529         // TODO consider using getSequenceSelection instead here
530         String reply = new AppletFormatAdapter().formatSequences(theFormat,
531                 new Alignment(alf.viewport.getSelectionAsNewSequence()),
532                 seqlimits);
533         return reply;
534       }
535     } catch (IllegalArgumentException ex)
536     {
537       ex.printStackTrace();
538       return "Error retrieving alignment, possibly invalid format specifier: "
539               + format;
540     }
541     return "";
542   }
543
544   /*
545    * (non-Javadoc)
546    * 
547    * @see jalview.bin.JalviewLiteJsApi#getAlignmentOrder()
548    */
549   @Override
550   public String getAlignmentOrder()
551   {
552     return getAlignmentOrderFrom(getDefaultTargetFrame());
553   }
554
555   /*
556    * (non-Javadoc)
557    * 
558    * @see
559    * jalview.bin.JalviewLiteJsApi#getAlignmentOrderFrom(jalview.appletgui.AlignFrame
560    * )
561    */
562   @Override
563   public String getAlignmentOrderFrom(AlignFrame alf)
564   {
565     return getAlignmentOrderFrom(alf, separator);
566   }
567
568   /*
569    * (non-Javadoc)
570    * 
571    * @see
572    * jalview.bin.JalviewLiteJsApi#getAlignmentOrderFrom(jalview.appletgui.AlignFrame
573    * , java.lang.String)
574    */
575   @Override
576   public String getAlignmentOrderFrom(AlignFrame alf, String sep)
577   {
578     AlignmentI alorder = alf.getAlignViewport().getAlignment();
579     String[] order = new String[alorder.getHeight()];
580     for (int i = 0; i < order.length; i++)
581     {
582       order[i] = alorder.getSequenceAt(i).getName();
583     }
584     return arrayToSeparatorList(order);
585   }
586
587   /*
588    * (non-Javadoc)
589    * 
590    * @see jalview.bin.JalviewLiteJsApi#orderBy(java.lang.String,
591    * java.lang.String)
592    */
593   @Override
594   public String orderBy(String order, String undoName)
595   {
596     return orderBy(order, undoName, separator);
597   }
598
599   /*
600    * (non-Javadoc)
601    * 
602    * @see jalview.bin.JalviewLiteJsApi#orderBy(java.lang.String,
603    * java.lang.String, java.lang.String)
604    */
605   @Override
606   public String orderBy(String order, String undoName, String sep)
607   {
608     return orderAlignmentBy(getDefaultTargetFrame(), order, undoName, sep);
609   }
610
611   /*
612    * (non-Javadoc)
613    * 
614    * @see
615    * jalview.bin.JalviewLiteJsApi#orderAlignmentBy(jalview.appletgui.AlignFrame,
616    * java.lang.String, java.lang.String, java.lang.String)
617    */
618   @Override
619   public String orderAlignmentBy(AlignFrame alf, String order,
620           String undoName, String sep)
621   {
622     String[] ids = separatorListToArray(order, sep);
623     SequenceI[] sqs = null;
624     if (ids != null && ids.length > 0)
625     {
626       jalview.analysis.SequenceIdMatcher matcher = new jalview.analysis.SequenceIdMatcher(
627               alf.viewport.getAlignment().getSequencesArray());
628       int s = 0;
629       sqs = new SequenceI[ids.length];
630       for (int i = 0; i < ids.length; i++)
631       {
632         if (ids[i].trim().length() == 0)
633         {
634           continue;
635         }
636         SequenceI sq = matcher.findIdMatch(ids[i]);
637         if (sq != null)
638         {
639           sqs[s++] = sq;
640         }
641       }
642       if (s > 0)
643       {
644         SequenceI[] sqq = new SequenceI[s];
645         System.arraycopy(sqs, 0, sqq, 0, s);
646         sqs = sqq;
647       }
648       else
649       {
650         sqs = null;
651       }
652     }
653     if (sqs == null)
654     {
655       return "";
656     }
657     ;
658     final AlignmentOrder aorder = new AlignmentOrder(sqs);
659
660     if (undoName != null && undoName.trim().length() == 0)
661     {
662       undoName = null;
663     }
664     final String _undoName = undoName;
665     // TODO: deal with synchronization here: cannot raise any events until after
666     // this has returned.
667     return alf.sortBy(aorder, _undoName) ? TRUE : "";
668   }
669
670   /*
671    * (non-Javadoc)
672    * 
673    * @see jalview.bin.JalviewLiteJsApi#getAlignment(java.lang.String)
674    */
675   @Override
676   public String getAlignment(String format)
677   {
678     return getAlignmentFrom(getDefaultTargetFrame(), format, TRUE);
679   }
680
681   /*
682    * (non-Javadoc)
683    * 
684    * @see
685    * jalview.bin.JalviewLiteJsApi#getAlignmentFrom(jalview.appletgui.AlignFrame,
686    * java.lang.String)
687    */
688   @Override
689   public String getAlignmentFrom(AlignFrame alf, String format)
690   {
691     return getAlignmentFrom(alf, format, TRUE);
692   }
693
694   /*
695    * (non-Javadoc)
696    * 
697    * @see jalview.bin.JalviewLiteJsApi#getAlignment(java.lang.String,
698    * java.lang.String)
699    */
700   @Override
701   public String getAlignment(String format, String suffix)
702   {
703     return getAlignmentFrom(getDefaultTargetFrame(), format, suffix);
704   }
705
706   /*
707    * (non-Javadoc)
708    * 
709    * @see
710    * jalview.bin.JalviewLiteJsApi#getAlignmentFrom(jalview.appletgui.AlignFrame,
711    * java.lang.String, java.lang.String)
712    */
713   @Override
714   public String getAlignmentFrom(AlignFrame alf, String format,
715           String suffix)
716   {
717     try
718     {
719       boolean seqlimits = suffix.equalsIgnoreCase(TRUE);
720
721       FileFormatI theFormat = FileFormats.getInstance().forName(format);
722       String reply = new AppletFormatAdapter().formatSequences(theFormat,
723               alf.viewport.getAlignment(), seqlimits);
724       return reply;
725     } catch (IllegalArgumentException ex)
726     {
727       ex.printStackTrace();
728       return "Error retrieving alignment, possibly invalid format specifier: "
729               + format;
730     }
731   }
732
733   /*
734    * (non-Javadoc)
735    * 
736    * @see jalview.bin.JalviewLiteJsApi#loadAnnotation(java.lang.String)
737    */
738   @Override
739   public void loadAnnotation(String annotation)
740   {
741     loadAnnotationFrom(getDefaultTargetFrame(), annotation);
742   }
743
744   /*
745    * (non-Javadoc)
746    * 
747    * @see
748    * jalview.bin.JalviewLiteJsApi#loadAnnotationFrom(jalview.appletgui.AlignFrame
749    * , java.lang.String)
750    */
751   @Override
752   public void loadAnnotationFrom(AlignFrame alf, String annotation)
753   {
754     if (new AnnotationFile().annotateAlignmentView(alf.getAlignViewport(),
755             annotation, DataSourceType.PASTE))
756     {
757       alf.alignPanel.fontChanged();
758       alf.alignPanel.setScrollValues(0, 0);
759     }
760     else
761     {
762       alf.parseFeaturesFile(annotation, DataSourceType.PASTE);
763     }
764   }
765
766   /*
767    * (non-Javadoc)
768    * 
769    * @see jalview.bin.JalviewLiteJsApi#loadAnnotation(java.lang.String)
770    */
771   @Override
772   public void loadFeatures(String features, boolean autoenabledisplay)
773   {
774     loadFeaturesFrom(getDefaultTargetFrame(), features, autoenabledisplay);
775   }
776
777   /*
778    * (non-Javadoc)
779    * 
780    * @see
781    * jalview.bin.JalviewLiteJsApi#loadAnnotationFrom(jalview.appletgui.AlignFrame
782    * , java.lang.String)
783    */
784   @Override
785   public boolean loadFeaturesFrom(AlignFrame alf, String features,
786           boolean autoenabledisplay)
787   {
788     return alf.parseFeaturesFile(features, DataSourceType.PASTE,
789             autoenabledisplay);
790   }
791
792   /*
793    * (non-Javadoc)
794    * 
795    * @see jalview.bin.JalviewLiteJsApi#getFeatures(java.lang.String)
796    */
797   @Override
798   public String getFeatures(String format)
799   {
800     return getFeaturesFrom(getDefaultTargetFrame(), format);
801   }
802
803   /*
804    * (non-Javadoc)
805    * 
806    * @see
807    * jalview.bin.JalviewLiteJsApi#getFeaturesFrom(jalview.appletgui.AlignFrame,
808    * java.lang.String)
809    */
810   @Override
811   public String getFeaturesFrom(AlignFrame alf, String format)
812   {
813     return alf.outputFeatures(false, format);
814   }
815
816   /*
817    * (non-Javadoc)
818    * 
819    * @see jalview.bin.JalviewLiteJsApi#getAnnotation()
820    */
821   @Override
822   public String getAnnotation()
823   {
824     return getAnnotationFrom(getDefaultTargetFrame());
825   }
826
827   /*
828    * (non-Javadoc)
829    * 
830    * @see
831    * jalview.bin.JalviewLiteJsApi#getAnnotationFrom(jalview.appletgui.AlignFrame
832    * )
833    */
834   @Override
835   public String getAnnotationFrom(AlignFrame alf)
836   {
837     return alf.outputAnnotations(false);
838   }
839
840   /*
841    * (non-Javadoc)
842    * 
843    * @see jalview.bin.JalviewLiteJsApi#newView()
844    */
845   @Override
846   public AlignFrame newView()
847   {
848     return newViewFrom(getDefaultTargetFrame());
849   }
850
851   /*
852    * (non-Javadoc)
853    * 
854    * @see jalview.bin.JalviewLiteJsApi#newView(java.lang.String)
855    */
856   @Override
857   public AlignFrame newView(String name)
858   {
859     return newViewFrom(getDefaultTargetFrame(), name);
860   }
861
862   /*
863    * (non-Javadoc)
864    * 
865    * @see jalview.bin.JalviewLiteJsApi#newViewFrom(jalview.appletgui.AlignFrame)
866    */
867   @Override
868   public AlignFrame newViewFrom(AlignFrame alf)
869   {
870     return alf.newView(null);
871   }
872
873   /*
874    * (non-Javadoc)
875    * 
876    * @see jalview.bin.JalviewLiteJsApi#newViewFrom(jalview.appletgui.AlignFrame,
877    * java.lang.String)
878    */
879   @Override
880   public AlignFrame newViewFrom(AlignFrame alf, String name)
881   {
882     return alf.newView(name);
883   }
884
885   /*
886    * (non-Javadoc)
887    * 
888    * @see jalview.bin.JalviewLiteJsApi#loadAlignment(java.lang.String,
889    * java.lang.String)
890    */
891   @Override
892   public AlignFrame loadAlignment(String text, String title)
893   {
894     AlignmentI al = null;
895
896     try
897     {
898       FileFormatI format = new IdentifyFile().identify(text,
899               DataSourceType.PASTE);
900       al = new AppletFormatAdapter().readFile(text, DataSourceType.PASTE,
901               format);
902       if (al.getHeight() > 0)
903       {
904         return new AlignFrame(al, this, title, false);
905       }
906     } catch (IOException ex)
907     {
908       ex.printStackTrace();
909     }
910     return null;
911   }
912
913   /*
914    * (non-Javadoc)
915    * 
916    * @see jalview.bin.JalviewLiteJsApi#setMouseoverListener(java.lang.String)
917    */
918   @Override
919   public void setMouseoverListener(String listener)
920   {
921     setMouseoverListener(currentAlignFrame, listener);
922   }
923
924   private Vector<jalview.javascript.JSFunctionExec> javascriptListeners = new Vector<jalview.javascript.JSFunctionExec>();
925
926   /*
927    * (non-Javadoc)
928    * 
929    * @see
930    * jalview.bin.JalviewLiteJsApi#setMouseoverListener(jalview.appletgui.AlignFrame
931    * , java.lang.String)
932    */
933   @Override
934   public void setMouseoverListener(AlignFrame af, String listener)
935   {
936     if (listener != null)
937     {
938       listener = listener.trim();
939       if (listener.length() == 0)
940       {
941         System.err
942                 .println("jalview Javascript error: Ignoring empty function for mouseover listener.");
943         return;
944       }
945     }
946     jalview.javascript.MouseOverListener mol = new jalview.javascript.MouseOverListener(
947             this, af, listener);
948     javascriptListeners.addElement(mol);
949     StructureSelectionManager.getStructureSelectionManager(this)
950             .addStructureViewerListener(mol);
951     if (debug)
952     {
953       System.err.println("Added a mouseover listener for "
954               + ((af == null) ? "All frames" : "Just views for "
955                       + af.getAlignViewport().getSequenceSetId()));
956       System.err.println("There are now " + javascriptListeners.size()
957               + " listeners in total.");
958     }
959   }
960
961   /*
962    * (non-Javadoc)
963    * 
964    * @see jalview.bin.JalviewLiteJsApi#setSelectionListener(java.lang.String)
965    */
966   @Override
967   public void setSelectionListener(String listener)
968   {
969     setSelectionListener(null, listener);
970   }
971
972   /*
973    * (non-Javadoc)
974    * 
975    * @see
976    * jalview.bin.JalviewLiteJsApi#setSelectionListener(jalview.appletgui.AlignFrame
977    * , java.lang.String)
978    */
979   @Override
980   public void setSelectionListener(AlignFrame af, String listener)
981   {
982     if (listener != null)
983     {
984       listener = listener.trim();
985       if (listener.length() == 0)
986       {
987         System.err
988                 .println("jalview Javascript error: Ignoring empty function for selection listener.");
989         return;
990       }
991     }
992     jalview.javascript.JsSelectionSender mol = new jalview.javascript.JsSelectionSender(
993             this, af, listener);
994     javascriptListeners.addElement(mol);
995     StructureSelectionManager.getStructureSelectionManager(this)
996             .addSelectionListener(mol);
997     if (debug)
998     {
999       System.err.println("Added a selection listener for "
1000               + ((af == null) ? "All frames" : "Just views for "
1001                       + af.getAlignViewport().getSequenceSetId()));
1002       System.err.println("There are now " + javascriptListeners.size()
1003               + " listeners in total.");
1004     }
1005   }
1006
1007   /**
1008    * Callable from javascript to register a javascript function to pass events
1009    * to a structure viewer.
1010    *
1011    * @param listener
1012    *          the name of a javascript function
1013    * @param modelSet
1014    *          a token separated list of PDB file names listened for
1015    * @see jalview.bin.JalviewLiteJsApi#setStructureListener(java.lang.String,
1016    *      java.lang.String)
1017    */
1018   @Override
1019   public void setStructureListener(String listener, String modelSet)
1020   {
1021     if (listener != null)
1022     {
1023       listener = listener.trim();
1024       if (listener.length() == 0)
1025       {
1026         System.err
1027                 .println("jalview Javascript error: Ignoring empty function for selection listener.");
1028         return;
1029       }
1030     }
1031     MouseOverStructureListener mol = new MouseOverStructureListener(this,
1032             listener, separatorListToArray(modelSet));
1033     javascriptListeners.addElement(mol);
1034     StructureSelectionManager.getStructureSelectionManager(this)
1035             .addStructureViewerListener(mol);
1036     if (debug)
1037     {
1038       System.err.println("Added a javascript structure viewer listener '"
1039               + listener + "'");
1040       System.err.println("There are now " + javascriptListeners.size()
1041               + " listeners in total.");
1042     }
1043   }
1044
1045   /*
1046    * (non-Javadoc)
1047    * 
1048    * @see
1049    * jalview.bin.JalviewLiteJsApi#removeJavascriptListener(jalview.appletgui
1050    * .AlignFrame, java.lang.String)
1051    */
1052   @Override
1053   public void removeJavascriptListener(AlignFrame af, String listener)
1054   {
1055     if (listener != null)
1056     {
1057       listener = listener.trim();
1058       if (listener.length() == 0)
1059       {
1060         listener = null;
1061       }
1062     }
1063     boolean rprt = false;
1064     for (int ms = 0, msSize = javascriptListeners.size(); ms < msSize;)
1065     {
1066       Object lstn = javascriptListeners.elementAt(ms);
1067       JsCallBack lstner = (JsCallBack) lstn;
1068       if ((af == null || lstner.getAlignFrame() == af)
1069               && (listener == null || lstner.getListenerFunction().equals(
1070                       listener)))
1071       {
1072         javascriptListeners.removeElement(lstner);
1073         msSize--;
1074         if (lstner instanceof SelectionListener)
1075         {
1076           StructureSelectionManager.getStructureSelectionManager(this)
1077                   .removeSelectionListener((SelectionListener) lstner);
1078         }
1079         else
1080         {
1081           StructureSelectionManager.getStructureSelectionManager(this)
1082                   .removeStructureViewerListener(lstner, null);
1083         }
1084         rprt = debug;
1085         if (debug)
1086         {
1087           System.err.println("Removed listener '" + listener + "'");
1088         }
1089       }
1090       else
1091       {
1092         ms++;
1093       }
1094     }
1095     if (rprt)
1096     {
1097       System.err.println("There are now " + javascriptListeners.size()
1098               + " listeners in total.");
1099     }
1100   }
1101
1102   @Override
1103   public void stop()
1104   {
1105     System.err.println("Applet " + getName() + " stop().");
1106     tidyUp();
1107   }
1108
1109   @Override
1110   public void destroy()
1111   {
1112     System.err.println("Applet " + getName() + " destroy().");
1113     tidyUp();
1114   }
1115
1116   private void tidyUp()
1117   {
1118     removeAll();
1119     if (currentAlignFrame != null && currentAlignFrame.viewport != null
1120             && currentAlignFrame.viewport.applet != null)
1121     {
1122       AlignViewport av = currentAlignFrame.viewport;
1123       currentAlignFrame.closeMenuItem_actionPerformed();
1124       av.applet = null;
1125       currentAlignFrame = null;
1126     }
1127     if (javascriptListeners != null)
1128     {
1129       while (javascriptListeners.size() > 0)
1130       {
1131         jalview.javascript.JSFunctionExec mol = javascriptListeners
1132                 .elementAt(0);
1133         javascriptListeners.removeElement(mol);
1134         if (mol instanceof SelectionListener)
1135         {
1136           StructureSelectionManager.getStructureSelectionManager(this)
1137                   .removeSelectionListener((SelectionListener) mol);
1138         }
1139         else
1140         {
1141           StructureSelectionManager.getStructureSelectionManager(this)
1142                   .removeStructureViewerListener(mol, null);
1143         }
1144         mol.jvlite = null;
1145       }
1146     }
1147     if (jsFunctionExec != null)
1148     {
1149       jsFunctionExec.stopQueue();
1150       jsFunctionExec.jvlite = null;
1151     }
1152     initialAlignFrame = null;
1153     jsFunctionExec = null;
1154     javascriptListeners = null;
1155     StructureSelectionManager.release(this);
1156   }
1157
1158   private jalview.javascript.JSFunctionExec jsFunctionExec;
1159
1160   /*
1161    * (non-Javadoc)
1162    * 
1163    * @see jalview.bin.JalviewLiteJsApi#mouseOverStructure(java.lang.String,
1164    * java.lang.String, java.lang.String)
1165    */
1166   @Override
1167   public void mouseOverStructure(final String pdbResNum,
1168           final String chain, final String pdbfile)
1169   {
1170     final StructureSelectionManagerProvider me = this;
1171     java.awt.EventQueue.invokeLater(new Runnable()
1172     {
1173       @Override
1174       public void run()
1175       {
1176         try
1177         {
1178           StructureSelectionManager.getStructureSelectionManager(me)
1179                   .mouseOverStructure(new Integer(pdbResNum).intValue(),
1180                           chain, pdbfile);
1181           if (debug)
1182           {
1183             System.err.println("mouseOver for '" + pdbResNum
1184                     + "' in chain '" + chain + "' in structure '" + pdbfile
1185                     + "'");
1186           }
1187         } catch (NumberFormatException e)
1188         {
1189           System.err.println("Ignoring invalid residue number string '"
1190                   + pdbResNum + "'");
1191         }
1192
1193       }
1194     });
1195   }
1196
1197   /*
1198    * (non-Javadoc)
1199    * 
1200    * @see
1201    * jalview.bin.JalviewLiteJsApi#scrollViewToIn(jalview.appletgui.AlignFrame,
1202    * java.lang.String, java.lang.String)
1203    */
1204   @Override
1205   public void scrollViewToIn(final AlignFrame alf, final String topRow,
1206           final String leftHandColumn)
1207   {
1208     java.awt.EventQueue.invokeLater(new Runnable()
1209     {
1210       @Override
1211       public void run()
1212       {
1213         try
1214         {
1215           alf.scrollTo(new Integer(topRow).intValue(), new Integer(
1216                   leftHandColumn).intValue());
1217
1218         } catch (Exception ex)
1219         {
1220           System.err.println("Couldn't parse integer arguments (topRow='"
1221                   + topRow + "' and leftHandColumn='" + leftHandColumn
1222                   + "')");
1223           ex.printStackTrace();
1224         }
1225       }
1226     });
1227   }
1228
1229   /*
1230    * (non-Javadoc)
1231    * 
1232    * @see
1233    * jalview.javascript.JalviewLiteJsApi#scrollViewToRowIn(jalview.appletgui
1234    * .AlignFrame, java.lang.String)
1235    */
1236   @Override
1237   public void scrollViewToRowIn(final AlignFrame alf, final String topRow)
1238   {
1239
1240     java.awt.EventQueue.invokeLater(new Runnable()
1241     {
1242       @Override
1243       public void run()
1244       {
1245         try
1246         {
1247           alf.scrollToRow(new Integer(topRow).intValue());
1248
1249         } catch (Exception ex)
1250         {
1251           System.err.println("Couldn't parse integer arguments (topRow='"
1252                   + topRow + "')");
1253           ex.printStackTrace();
1254         }
1255
1256       }
1257     });
1258   }
1259
1260   /*
1261    * (non-Javadoc)
1262    * 
1263    * @see
1264    * jalview.javascript.JalviewLiteJsApi#scrollViewToColumnIn(jalview.appletgui
1265    * .AlignFrame, java.lang.String)
1266    */
1267   @Override
1268   public void scrollViewToColumnIn(final AlignFrame alf,
1269           final String leftHandColumn)
1270   {
1271     java.awt.EventQueue.invokeLater(new Runnable()
1272     {
1273
1274       @Override
1275       public void run()
1276       {
1277         try
1278         {
1279           alf.scrollToColumn(new Integer(leftHandColumn).intValue());
1280
1281         } catch (Exception ex)
1282         {
1283           System.err
1284                   .println("Couldn't parse integer arguments (leftHandColumn='"
1285                           + leftHandColumn + "')");
1286           ex.printStackTrace();
1287         }
1288       }
1289     });
1290
1291   }
1292
1293   // //////////////////////////////////////////////
1294   // //////////////////////////////////////////////
1295
1296   public static int lastFrameX = 200;
1297
1298   public static int lastFrameY = 200;
1299
1300   boolean fileFound = true;
1301
1302   String file = "No file";
1303
1304   String file2 = null;
1305
1306   Button launcher = new Button(
1307           MessageManager.getString("label.start_jalview"));
1308
1309   /**
1310    * The currentAlignFrame is static, it will change if and when the user
1311    * selects a new window. Note that it will *never* point back to the embedded
1312    * AlignFrame if the applet is started as embedded on the page and then
1313    * afterwards a new view is created.
1314    */
1315   public AlignFrame currentAlignFrame = null;
1316
1317   /**
1318    * This is the first frame to be displayed, and does not change. API calls
1319    * will default to this instance if currentAlignFrame is null.
1320    */
1321   AlignFrame initialAlignFrame = null;
1322
1323   boolean embedded = false;
1324
1325   private boolean checkForJmol = true;
1326
1327   private boolean checkedForJmol = false; // ensure we don't check for jmol
1328
1329   // every time the app is re-inited
1330
1331   public boolean jmolAvailable = false;
1332
1333   private boolean alignPdbStructures = false;
1334
1335   /**
1336    * use an external structure viewer exclusively (no jmols or MCViews will be
1337    * opened by JalviewLite itself)
1338    */
1339   public boolean useXtrnalSviewer = false;
1340
1341   public static boolean debug = false;
1342
1343   static String builddate = null, version = null, installation = null;
1344
1345   private static void initBuildDetails()
1346   {
1347     if (builddate == null)
1348     {
1349       builddate = "unknown";
1350       version = "test";
1351       installation = "applet";
1352       java.net.URL url = JalviewLite.class
1353               .getResource("/.build_properties");
1354       if (url != null)
1355       {
1356         try
1357         {
1358           BufferedReader reader = new BufferedReader(new InputStreamReader(
1359                   url.openStream()));
1360           String line;
1361           while ((line = reader.readLine()) != null)
1362           {
1363             if (line.indexOf("VERSION") > -1)
1364             {
1365               version = line.substring(line.indexOf("=") + 1);
1366             }
1367             if (line.indexOf("BUILD_DATE") > -1)
1368             {
1369               builddate = line.substring(line.indexOf("=") + 1);
1370             }
1371             if (line.indexOf("INSTALLATION") > -1)
1372             {
1373               installation = line.substring(line.indexOf("=") + 1);
1374             }
1375           }
1376         } catch (Exception ex)
1377         {
1378           ex.printStackTrace();
1379         }
1380       }
1381     }
1382   }
1383
1384   public static String getBuildDate()
1385   {
1386     initBuildDetails();
1387     return builddate;
1388   }
1389
1390   public static String getInstallation()
1391   {
1392     initBuildDetails();
1393     return installation;
1394   }
1395
1396   public static String getVersion()
1397   {
1398     initBuildDetails();
1399     return version;
1400   }
1401
1402   // public JSObject scriptObject = null;
1403
1404   /**
1405    * init method for Jalview Applet
1406    */
1407   @Override
1408   public void init()
1409   {
1410     debug = TRUE.equalsIgnoreCase(getParameter("debug"));
1411     try
1412     {
1413       if (debug)
1414       {
1415         System.err.println("Applet context is '"
1416                 + getAppletContext().getClass().toString() + "'");
1417       }
1418       JSObject scriptObject = JSObject.getWindow(this);
1419       if (debug && scriptObject != null)
1420       {
1421         System.err.println("Applet has Javascript callback support.");
1422       }
1423
1424     } catch (Exception ex)
1425     {
1426       System.err
1427               .println("Warning: No JalviewLite javascript callbacks available.");
1428       if (debug)
1429       {
1430         ex.printStackTrace();
1431       }
1432     }
1433
1434     if (debug)
1435     {
1436       System.err.println("JalviewLite Version " + getVersion());
1437       System.err.println("Build Date : " + getBuildDate());
1438       System.err.println("Installation : " + getInstallation());
1439     }
1440     String externalsviewer = getParameter("externalstructureviewer");
1441     if (externalsviewer != null)
1442     {
1443       useXtrnalSviewer = externalsviewer.trim().toLowerCase().equals(TRUE);
1444     }
1445     /**
1446      * if true disable the check for jmol
1447      */
1448     String chkforJmol = getParameter("nojmol");
1449     if (chkforJmol != null)
1450     {
1451       checkForJmol = !chkforJmol.equals(TRUE);
1452     }
1453     /**
1454      * get the separator parameter if present
1455      */
1456     String sep = getParameter("separator");
1457     if (sep != null)
1458     {
1459       if (sep.length() > 0)
1460       {
1461         separator = sep;
1462         if (debug)
1463         {
1464           System.err.println("Separator set to '" + separator + "'");
1465         }
1466       }
1467       else
1468       {
1469         throw new Error(
1470                 MessageManager
1471                         .getString("error.invalid_separator_parameter"));
1472       }
1473     }
1474     int r = 255;
1475     int g = 255;
1476     int b = 255;
1477     String param = getParameter("RGB");
1478
1479     if (param != null)
1480     {
1481       try
1482       {
1483         r = Integer.parseInt(param.substring(0, 2), 16);
1484         g = Integer.parseInt(param.substring(2, 4), 16);
1485         b = Integer.parseInt(param.substring(4, 6), 16);
1486       } catch (Exception ex)
1487       {
1488         r = 255;
1489         g = 255;
1490         b = 255;
1491       }
1492     }
1493     param = getParameter("label");
1494     if (param != null)
1495     {
1496       launcher.setLabel(param);
1497     }
1498
1499     setBackground(new Color(r, g, b));
1500
1501     file = getParameter("file");
1502
1503     if (file == null)
1504     {
1505       // Maybe the sequences are added as parameters
1506       StringBuffer data = new StringBuffer("PASTE");
1507       int i = 1;
1508       while ((file = getParameter("sequence" + i)) != null)
1509       {
1510         data.append(file.toString() + "\n");
1511         i++;
1512       }
1513       if (data.length() > 5)
1514       {
1515         file = data.toString();
1516       }
1517     }
1518     if (getDefaultParameter("enableSplitFrame", true))
1519     {
1520       file2 = getParameter("file2");
1521     }
1522
1523     embedded = TRUE.equalsIgnoreCase(getParameter("embedded"));
1524     if (embedded)
1525     {
1526       LoadingThread loader = new LoadingThread(file, file2, this);
1527       loader.start();
1528     }
1529     else if (file != null)
1530     {
1531       /*
1532        * Start the applet immediately or show a button to start it
1533        */
1534       if (FALSE.equalsIgnoreCase(getParameter("showbutton")))
1535       {
1536         LoadingThread loader = new LoadingThread(file, file2, this);
1537         loader.start();
1538       }
1539       else
1540       {
1541         add(launcher);
1542         launcher.addActionListener(new java.awt.event.ActionListener()
1543         {
1544           @Override
1545           public void actionPerformed(ActionEvent e)
1546           {
1547             LoadingThread loader = new LoadingThread(file, file2,
1548                     JalviewLite.this);
1549             loader.start();
1550           }
1551         });
1552       }
1553     }
1554     else
1555     {
1556       // jalview initialisation with no alignment. loadAlignment() method can
1557       // still be called to open new alignments.
1558       file = "NO FILE";
1559       fileFound = false;
1560       callInitCallback();
1561     }
1562   }
1563
1564   private void initLiveConnect()
1565   {
1566     // try really hard to get the liveConnect thing working
1567     boolean notFailed = false;
1568     int tries = 0;
1569     while (!notFailed && tries < 10)
1570     {
1571       if (tries > 0)
1572       {
1573         System.err.println("LiveConnect request thread going to sleep.");
1574       }
1575       try
1576       {
1577         Thread.sleep(700 * (1 + tries));
1578       } catch (InterruptedException q)
1579       {
1580       }
1581       ;
1582       if (tries++ > 0)
1583       {
1584         System.err.println("LiveConnect request thread woken up.");
1585       }
1586       try
1587       {
1588         JSObject scriptObject = JSObject.getWindow(this);
1589         if (scriptObject.eval("navigator") != null)
1590         {
1591           notFailed = true;
1592         }
1593       } catch (Exception jsex)
1594       {
1595         System.err.println("Attempt " + tries
1596                 + " to access LiveConnect javascript failed.");
1597       }
1598     }
1599   }
1600
1601   private void callInitCallback()
1602   {
1603     String initjscallback = getParameter("oninit");
1604     if (initjscallback == null)
1605     {
1606       return;
1607     }
1608     initjscallback = initjscallback.trim();
1609     if (initjscallback.length() > 0)
1610     {
1611       JSObject scriptObject = null;
1612       try
1613       {
1614         scriptObject = JSObject.getWindow(this);
1615       } catch (Exception ex)
1616       {
1617       }
1618       ;
1619       // try really hard to let the browser plugin know we want liveconnect
1620       initLiveConnect();
1621
1622       if (scriptObject != null)
1623       {
1624         try
1625         {
1626           // do onInit with the JS executor thread
1627           new JSFunctionExec(this).executeJavascriptFunction(true,
1628                   initjscallback, null, "Calling oninit callback '"
1629                           + initjscallback + "'.");
1630         } catch (Exception e)
1631         {
1632           System.err.println("Exception when executing _oninit callback '"
1633                   + initjscallback + "'.");
1634           e.printStackTrace();
1635         }
1636       }
1637       else
1638       {
1639         System.err.println("Not executing _oninit callback '"
1640                 + initjscallback + "' - no scripting allowed.");
1641       }
1642     }
1643   }
1644
1645   /**
1646    * Initialises and displays a new java.awt.Frame
1647    * 
1648    * @param frame
1649    *          java.awt.Frame to be displayed
1650    * @param title
1651    *          title of new frame
1652    * @param width
1653    *          width if new frame
1654    * @param height
1655    *          height of new frame
1656    */
1657   public static void addFrame(final Frame frame, String title, int width,
1658           int height)
1659   {
1660     frame.setLocation(lastFrameX, lastFrameY);
1661     lastFrameX += 40;
1662     lastFrameY += 40;
1663     frame.setSize(width, height);
1664     frame.setTitle(title);
1665     frame.addWindowListener(new WindowAdapter()
1666     {
1667       @Override
1668       public void windowClosing(WindowEvent e)
1669       {
1670         if (frame instanceof AlignFrame)
1671         {
1672           AlignViewport vp = ((AlignFrame) frame).viewport;
1673           ((AlignFrame) frame).closeMenuItem_actionPerformed();
1674           if (vp.applet.currentAlignFrame == frame)
1675           {
1676             vp.applet.currentAlignFrame = null;
1677           }
1678           vp.applet = null;
1679           vp = null;
1680
1681         }
1682         lastFrameX -= 40;
1683         lastFrameY -= 40;
1684         if (frame instanceof EmbmenuFrame)
1685         {
1686           ((EmbmenuFrame) frame).destroyMenus();
1687         }
1688         frame.setMenuBar(null);
1689         frame.dispose();
1690       }
1691
1692       @Override
1693       public void windowActivated(WindowEvent e)
1694       {
1695         if (frame instanceof AlignFrame)
1696         {
1697           ((AlignFrame) frame).viewport.applet.currentAlignFrame = (AlignFrame) frame;
1698           if (debug)
1699           {
1700             System.err.println("Activated window " + frame);
1701           }
1702         }
1703         // be good.
1704         super.windowActivated(e);
1705       }
1706       /*
1707        * Probably not necessary to do this - see TODO above. (non-Javadoc)
1708        * 
1709        * @see
1710        * java.awt.event.WindowAdapter#windowDeactivated(java.awt.event.WindowEvent
1711        * )
1712        * 
1713        * public void windowDeactivated(WindowEvent e) { if (currentAlignFrame ==
1714        * frame) { currentAlignFrame = null; if (debug) {
1715        * System.err.println("Deactivated window "+frame); } }
1716        * super.windowDeactivated(e); }
1717        */
1718     });
1719     frame.setVisible(true);
1720   }
1721
1722   /**
1723    * This paints the background surrounding the "Launch Jalview button" <br>
1724    * <br>
1725    * If file given in parameter not found, displays error message
1726    * 
1727    * @param g
1728    *          graphics context
1729    */
1730   @Override
1731   public void paint(Graphics g)
1732   {
1733     if (!fileFound)
1734     {
1735       g.setColor(new Color(200, 200, 200));
1736       g.setColor(Color.cyan);
1737       g.fillRect(0, 0, getSize().width, getSize().height);
1738       g.setColor(Color.red);
1739       g.drawString(
1740               MessageManager.getString("label.jalview_cannot_open_file"),
1741               5, 15);
1742       g.drawString("\"" + file + "\"", 5, 30);
1743     }
1744     else if (embedded)
1745     {
1746       g.setColor(Color.black);
1747       g.setFont(new Font("Arial", Font.BOLD, 24));
1748       g.drawString(MessageManager.getString("label.jalview_applet"), 50,
1749               getSize().height / 2 - 30);
1750       g.drawString(MessageManager.getString("label.loading_data") + "...",
1751               50, getSize().height / 2);
1752     }
1753   }
1754
1755   /**
1756    * get all components associated with the applet of the given type
1757    * 
1758    * @param class1
1759    * @return
1760    */
1761   public Vector getAppletWindow(Class class1)
1762   {
1763     Vector wnds = new Vector();
1764     Component[] cmp = getComponents();
1765     if (cmp != null)
1766     {
1767       for (int i = 0; i < cmp.length; i++)
1768       {
1769         if (class1.isAssignableFrom(cmp[i].getClass()))
1770         {
1771           wnds.addElement(cmp);
1772         }
1773       }
1774     }
1775     return wnds;
1776   }
1777
1778   class LoadJmolThread extends Thread
1779   {
1780     private boolean running = false;
1781
1782     @Override
1783     public void run()
1784     {
1785       if (running || checkedForJmol)
1786       {
1787         return;
1788       }
1789       running = true;
1790       if (checkForJmol)
1791       {
1792         try
1793         {
1794           if (!System.getProperty("java.version").startsWith("1.1"))
1795           {
1796             Class.forName("org.jmol.adapter.smarter.SmarterJmolAdapter");
1797             jmolAvailable = true;
1798           }
1799           if (!jmolAvailable)
1800           {
1801             System.out
1802                     .println("Jmol not available - Using MCview for structures");
1803           }
1804         } catch (java.lang.ClassNotFoundException ex)
1805         {
1806         }
1807       }
1808       else
1809       {
1810         jmolAvailable = false;
1811         if (debug)
1812         {
1813           System.err
1814                   .println("Skipping Jmol check. Will use MCView (probably)");
1815         }
1816       }
1817       checkedForJmol = true;
1818       running = false;
1819     }
1820
1821     public boolean notFinished()
1822     {
1823       return running || !checkedForJmol;
1824     }
1825   }
1826
1827   class LoadingThread extends Thread
1828   {
1829     /**
1830      * State variable: protocol for access to file source
1831      */
1832     DataSourceType protocol;
1833
1834     String _file; // alignment file or URL spec
1835
1836     String _file2; // second alignment file or URL spec
1837
1838     JalviewLite applet;
1839
1840     private void dbgMsg(String msg)
1841     {
1842       if (JalviewLite.debug)
1843       {
1844         System.err.println(msg);
1845       }
1846     }
1847
1848     /**
1849      * update the protocol state variable for accessing the datasource located
1850      * by file.
1851      * 
1852      * @param path
1853      * @return possibly updated datasource string
1854      */
1855     public String resolveFileProtocol(String path)
1856     {
1857       /*
1858        * is it paste data?
1859        */
1860       if (path.startsWith("PASTE"))
1861       {
1862         protocol = DataSourceType.PASTE;
1863         return path.substring(5);
1864       }
1865
1866       /*
1867        * is it a URL?
1868        */
1869       if (path.indexOf("://") != -1)
1870       {
1871         protocol = DataSourceType.URL;
1872         return path;
1873       }
1874
1875       /*
1876        * try relative to document root
1877        */
1878       URL documentBase = getDocumentBase();
1879       String withDocBase = resolveUrlForLocalOrAbsolute(path, documentBase);
1880       if (HttpUtils.isValidUrl(withDocBase))
1881       {
1882         if (debug)
1883         {
1884           System.err.println("Prepended document base '" + documentBase
1885                   + "' to make: '" + withDocBase + "'");
1886         }
1887         protocol = DataSourceType.URL;
1888         return withDocBase;
1889       }
1890
1891       /*
1892        * try relative to codebase (if different to document base)
1893        */
1894       URL codeBase = getCodeBase();
1895       String withCodeBase = applet.resolveUrlForLocalOrAbsolute(path,
1896               codeBase);
1897       if (!withCodeBase.equals(withDocBase)
1898               && HttpUtils.isValidUrl(withCodeBase))
1899       {
1900         protocol = DataSourceType.URL;
1901         if (debug)
1902         {
1903           System.err.println("Prepended codebase '" + codeBase
1904                   + "' to make: '" + withCodeBase + "'");
1905         }
1906         return withCodeBase;
1907       }
1908
1909       /*
1910        * try locating by classloader; try this last so files in the directory
1911        * are resolved using document base
1912        */
1913       if (inArchive(path))
1914       {
1915         protocol = DataSourceType.CLASSLOADER;
1916       }
1917       return path;
1918     }
1919
1920     public LoadingThread(String file, String file2, JalviewLite _applet)
1921     {
1922       this._file = file;
1923       this._file2 = file2;
1924       applet = _applet;
1925     }
1926
1927     @Override
1928     public void run()
1929     {
1930       LoadJmolThread jmolchecker = new LoadJmolThread();
1931       jmolchecker.start();
1932       while (jmolchecker.notFinished())
1933       {
1934         // wait around until the Jmol check is complete.
1935         try
1936         {
1937           Thread.sleep(2);
1938         } catch (Exception e)
1939         {
1940         }
1941       }
1942       startLoading();
1943       // applet.callInitCallback();
1944     }
1945
1946     /**
1947      * Load the alignment and any related files as specified by applet
1948      * parameters
1949      */
1950     private void startLoading()
1951     {
1952       dbgMsg("Loading thread started with:\n>>file\n" + _file + ">>endfile");
1953
1954       dbgMsg("Loading started.");
1955
1956       AlignFrame newAlignFrame = readAlignment(_file);
1957       AlignFrame newAlignFrame2 = readAlignment(_file2);
1958       if (newAlignFrame != null)
1959       {
1960         addToDisplay(newAlignFrame, newAlignFrame2);
1961         loadTree(newAlignFrame);
1962
1963         loadScoreFile(newAlignFrame);
1964
1965         loadFeatures(newAlignFrame);
1966
1967         loadAnnotations(newAlignFrame);
1968
1969         loadJnetFile(newAlignFrame);
1970
1971         loadPdbFiles(newAlignFrame);
1972       }
1973       else
1974       {
1975         fileFound = false;
1976         applet.remove(launcher);
1977         applet.repaint();
1978       }
1979       callInitCallback();
1980     }
1981
1982     /**
1983      * Add an AlignFrame to the display; or if two are provided, a SplitFrame.
1984      * 
1985      * @param af
1986      * @param af2
1987      */
1988     public void addToDisplay(AlignFrame af, AlignFrame af2)
1989     {
1990       if (af2 != null)
1991       {
1992         AlignmentI al1 = af.viewport.getAlignment();
1993         AlignmentI al2 = af2.viewport.getAlignment();
1994         AlignmentI cdna = al1.isNucleotide() ? al1 : al2;
1995         AlignmentI prot = al1.isNucleotide() ? al2 : al1;
1996         if (AlignmentUtils.mapProteinAlignmentToCdna(prot, cdna))
1997         {
1998           al2.alignAs(al1);
1999           SplitFrame sf = new SplitFrame(af, af2);
2000           sf.addToDisplay(embedded, JalviewLite.this);
2001           return;
2002         }
2003         else
2004         {
2005           String msg = "Could not map any sequence in " + af2.getTitle()
2006                   + " as "
2007                   + (al1.isNucleotide() ? "protein product" : "cDNA")
2008                   + " for " + af.getTitle();
2009           System.err.println(msg);
2010         }
2011       }
2012
2013       af.addToDisplay(embedded);
2014     }
2015
2016     /**
2017      * Read the alignment file (from URL, text 'paste', or archive by
2018      * classloader).
2019      * 
2020      * @return
2021      */
2022     protected AlignFrame readAlignment(String fileParam)
2023     {
2024       if (fileParam == null)
2025       {
2026         return null;
2027       }
2028       String resolvedFile = resolveFileProtocol(fileParam);
2029       AlignmentI al = null;
2030       try
2031       {
2032         FileFormatI format = new IdentifyFile().identify(resolvedFile,
2033                 protocol);
2034         dbgMsg("File identified as '" + format + "'");
2035         al = new AppletFormatAdapter().readFile(resolvedFile, protocol,
2036                 format);
2037         if ((al != null) && (al.getHeight() > 0))
2038         {
2039           dbgMsg("Successfully loaded file.");
2040           al.setDataset(null);
2041           AlignFrame newAlignFrame = new AlignFrame(al, applet,
2042                   resolvedFile, embedded, false);
2043           newAlignFrame.setTitle(resolvedFile);
2044           if (initialAlignFrame == null)
2045           {
2046             initialAlignFrame = newAlignFrame;
2047           }
2048           // update the focus.
2049           currentAlignFrame = newAlignFrame;
2050
2051           if (protocol == DataSourceType.PASTE)
2052           {
2053             newAlignFrame.setTitle(MessageManager.formatMessage(
2054                     "label.sequences_from", new Object[] { applet
2055                             .getDocumentBase().toString() }));
2056           }
2057
2058           newAlignFrame.statusBar.setText(MessageManager.formatMessage(
2059                   "label.successfully_loaded_file",
2060                   new Object[] { resolvedFile }));
2061
2062           return newAlignFrame;
2063         }
2064       } catch (java.io.IOException ex)
2065       {
2066         dbgMsg("File load exception.");
2067         ex.printStackTrace();
2068         if (debug)
2069         {
2070           try
2071           {
2072             FileParse fp = new FileParse(resolvedFile, protocol);
2073             String ln = null;
2074             dbgMsg(">>>Dumping contents of '" + resolvedFile + "' " + "("
2075                     + protocol + ")");
2076             while ((ln = fp.nextLine()) != null)
2077             {
2078               dbgMsg(ln);
2079             }
2080             dbgMsg(">>>Dump finished.");
2081           } catch (Exception e)
2082           {
2083             System.err
2084                     .println("Exception when trying to dump the content of the file parameter.");
2085             e.printStackTrace();
2086           }
2087         }
2088       }
2089       return null;
2090     }
2091
2092     /**
2093      * Load PDBFiles if any specified by parameter(s). Returns true if loaded,
2094      * else false.
2095      * 
2096      * @param alignFrame
2097      * @return
2098      */
2099     protected boolean loadPdbFiles(AlignFrame alignFrame)
2100     {
2101       boolean result = false;
2102       /*
2103        * <param name="alignpdbfiles" value="false/true"/> Undocumented for 2.6 -
2104        * related to JAL-434
2105        */
2106
2107       applet.setAlignPdbStructures(getDefaultParameter("alignpdbfiles",
2108               false));
2109       /*
2110        * <param name="PDBfile" value="1gaq.txt PDB|1GAQ|1GAQ|A PDB|1GAQ|1GAQ|B
2111        * PDB|1GAQ|1GAQ|C">
2112        * 
2113        * <param name="PDBfile2" value="1gaq.txt A=SEQA B=SEQB C=SEQB">
2114        * 
2115        * <param name="PDBfile3" value="1q0o Q45135_9MICO">
2116        */
2117
2118       int pdbFileCount = 0;
2119       // Accumulate pdbs here if they are heading for the same view (if
2120       // alignPdbStructures is true)
2121       Vector pdbs = new Vector();
2122       // create a lazy matcher if we're asked to
2123       jalview.analysis.SequenceIdMatcher matcher = (applet
2124               .getDefaultParameter("relaxedidmatch", false)) ? new jalview.analysis.SequenceIdMatcher(
2125               alignFrame.getAlignViewport().getAlignment()
2126                       .getSequencesArray()) : null;
2127
2128       String param;
2129       do
2130       {
2131         if (pdbFileCount > 0)
2132         {
2133           param = applet.getParameter("PDBFILE" + pdbFileCount);
2134         }
2135         else
2136         {
2137           param = applet.getParameter("PDBFILE");
2138         }
2139
2140         if (param != null)
2141         {
2142           PDBEntry pdb = new PDBEntry();
2143
2144           String seqstring;
2145           SequenceI[] seqs = null;
2146           String[] chains = null;
2147
2148           StringTokenizer st = new StringTokenizer(param, " ");
2149
2150           if (st.countTokens() < 2)
2151           {
2152             String sequence = applet.getParameter("PDBSEQ");
2153             if (sequence != null)
2154             {
2155               seqs = new SequenceI[] { matcher == null ? (Sequence) alignFrame
2156                       .getAlignViewport().getAlignment().findName(sequence)
2157                       : matcher.findIdMatch(sequence) };
2158             }
2159
2160           }
2161           else
2162           {
2163             param = st.nextToken();
2164             List<SequenceI> tmp = new ArrayList<SequenceI>();
2165             List<String> tmp2 = new ArrayList<String>();
2166
2167             while (st.hasMoreTokens())
2168             {
2169               seqstring = st.nextToken();
2170               StringTokenizer st2 = new StringTokenizer(seqstring, "=");
2171               if (st2.countTokens() > 1)
2172               {
2173                 // This is the chain
2174                 tmp2.add(st2.nextToken());
2175                 seqstring = st2.nextToken();
2176               }
2177               tmp.add(matcher == null ? (Sequence) alignFrame
2178                       .getAlignViewport().getAlignment()
2179                       .findName(seqstring) : matcher.findIdMatch(seqstring));
2180             }
2181
2182             seqs = tmp.toArray(new SequenceI[tmp.size()]);
2183             if (tmp2.size() == tmp.size())
2184             {
2185               chains = tmp2.toArray(new String[tmp2.size()]);
2186             }
2187           }
2188           param = resolveFileProtocol(param);
2189           // TODO check JAL-357 for files in a jar (CLASSLOADER)
2190           pdb.setFile(param);
2191
2192           if (seqs != null)
2193           {
2194             for (int i = 0; i < seqs.length; i++)
2195             {
2196               if (seqs[i] != null)
2197               {
2198                 ((Sequence) seqs[i]).addPDBId(pdb);
2199                 StructureSelectionManager.getStructureSelectionManager(
2200                         applet).registerPDBEntry(pdb);
2201               }
2202               else
2203               {
2204                 if (JalviewLite.debug)
2205                 {
2206                   // this may not really be a problem but we give a warning
2207                   // anyway
2208                   System.err
2209                           .println("Warning: Possible input parsing error: Null sequence for attachment of PDB (sequence "
2210                                   + i + ")");
2211                 }
2212               }
2213             }
2214
2215             if (!alignPdbStructures)
2216             {
2217               alignFrame.newStructureView(applet, pdb, seqs, chains,
2218                       protocol);
2219             }
2220             else
2221             {
2222               pdbs.addElement(new Object[] { pdb, seqs, chains, protocol });
2223             }
2224           }
2225         }
2226
2227         pdbFileCount++;
2228       } while (param != null || pdbFileCount < 10);
2229       if (pdbs.size() > 0)
2230       {
2231         SequenceI[][] seqs = new SequenceI[pdbs.size()][];
2232         PDBEntry[] pdb = new PDBEntry[pdbs.size()];
2233         String[][] chains = new String[pdbs.size()][];
2234         String[] protocols = new String[pdbs.size()];
2235         for (int pdbsi = 0, pdbsiSize = pdbs.size(); pdbsi < pdbsiSize; pdbsi++)
2236         {
2237           Object[] o = (Object[]) pdbs.elementAt(pdbsi);
2238           pdb[pdbsi] = (PDBEntry) o[0];
2239           seqs[pdbsi] = (SequenceI[]) o[1];
2240           chains[pdbsi] = (String[]) o[2];
2241           protocols[pdbsi] = (String) o[3];
2242         }
2243         alignFrame.alignedStructureView(applet, pdb, seqs, chains,
2244                 protocols);
2245         result = true;
2246       }
2247       return result;
2248     }
2249
2250     /**
2251      * Load in a Jnetfile if specified by parameter. Returns true if loaded,
2252      * else false.
2253      * 
2254      * @param alignFrame
2255      * @return
2256      */
2257     protected boolean loadJnetFile(AlignFrame alignFrame)
2258     {
2259       boolean result = false;
2260       String param = applet.getParameter("jnetfile");
2261       if (param == null)
2262       {
2263         // jnet became jpred around 2016
2264         param = applet.getParameter("jpredfile");
2265       }
2266       if (param != null)
2267       {
2268         try
2269         {
2270           param = resolveFileProtocol(param);
2271           JPredFile predictions = new JPredFile(param, protocol);
2272           JnetAnnotationMaker.add_annotation(predictions,
2273                   alignFrame.viewport.getAlignment(), 0, false);
2274           // false == do not add sequence profile from concise output
2275           SequenceI repseq = alignFrame.viewport.getAlignment()
2276                   .getSequenceAt(0);
2277           alignFrame.viewport.getAlignment().setSeqrep(repseq);
2278           HiddenColumns cs = new HiddenColumns();
2279           cs.hideInsertionsFor(repseq);
2280           alignFrame.viewport.getAlignment().setHiddenColumns(cs);
2281           alignFrame.alignPanel.fontChanged();
2282           alignFrame.alignPanel.setScrollValues(0, 0);
2283           result = true;
2284         } catch (Exception ex)
2285         {
2286           ex.printStackTrace();
2287         }
2288       }
2289       return result;
2290     }
2291
2292     /**
2293      * Load annotations if specified by parameter. Returns true if loaded, else
2294      * false.
2295      * 
2296      * @param alignFrame
2297      * @return
2298      */
2299     protected boolean loadAnnotations(AlignFrame alignFrame)
2300     {
2301       boolean result = false;
2302       String param = applet.getParameter("annotations");
2303       if (param != null)
2304       {
2305         param = resolveFileProtocol(param);
2306
2307         if (new AnnotationFile().annotateAlignmentView(alignFrame.viewport,
2308                 param, protocol))
2309         {
2310           alignFrame.alignPanel.fontChanged();
2311           alignFrame.alignPanel.setScrollValues(0, 0);
2312           result = true;
2313         }
2314         else
2315         {
2316           System.err
2317                   .println("Annotations were not added from annotation file '"
2318                           + param + "'");
2319         }
2320       }
2321       return result;
2322     }
2323
2324     /**
2325      * Load features file and view settings as specified by parameters. Returns
2326      * true if features were loaded, else false.
2327      * 
2328      * @param alignFrame
2329      * @return
2330      */
2331     protected boolean loadFeatures(AlignFrame alignFrame)
2332     {
2333       boolean result = false;
2334       // ///////////////////////////
2335       // modify display of features
2336       // we do this before any features have been loaded, ensuring any hidden
2337       // groups are hidden when features first displayed
2338       //
2339       // hide specific groups
2340       //
2341       String param = applet.getParameter("hidefeaturegroups");
2342       if (param != null)
2343       {
2344         alignFrame.setFeatureGroupState(separatorListToArray(param), false);
2345         // applet.setFeatureGroupStateOn(newAlignFrame, param, false);
2346       }
2347       // show specific groups
2348       param = applet.getParameter("showfeaturegroups");
2349       if (param != null)
2350       {
2351         alignFrame.setFeatureGroupState(separatorListToArray(param), true);
2352         // applet.setFeatureGroupStateOn(newAlignFrame, param, true);
2353       }
2354       // and now load features
2355       param = applet.getParameter("features");
2356       if (param != null)
2357       {
2358         param = resolveFileProtocol(param);
2359
2360         result = alignFrame.parseFeaturesFile(param, protocol);
2361       }
2362
2363       param = applet.getParameter("showFeatureSettings");
2364       if (param != null && param.equalsIgnoreCase(TRUE))
2365       {
2366         alignFrame.viewport.setShowSequenceFeatures(true);
2367         new FeatureSettings(alignFrame.alignPanel);
2368       }
2369       return result;
2370     }
2371
2372     /**
2373      * Load a score file if specified by parameter. Returns true if file was
2374      * loaded, else false.
2375      * 
2376      * @param alignFrame
2377      */
2378     protected boolean loadScoreFile(AlignFrame alignFrame)
2379     {
2380       boolean result = false;
2381       String sScoreFile = applet.getParameter("scoreFile");
2382       if (sScoreFile != null && !"".equals(sScoreFile))
2383       {
2384         try
2385         {
2386           if (debug)
2387           {
2388             System.err
2389                     .println("Attempting to load T-COFFEE score file from the scoreFile parameter");
2390           }
2391           result = alignFrame.loadScoreFile(sScoreFile);
2392           if (!result)
2393           {
2394             System.err
2395                     .println("Failed to parse T-COFFEE parameter as a valid score file ('"
2396                             + sScoreFile + "')");
2397           }
2398         } catch (Exception e)
2399         {
2400           System.err.printf("Cannot read score file: '%s'. Cause: %s \n",
2401                   sScoreFile, e.getMessage());
2402         }
2403       }
2404       return result;
2405     }
2406
2407     /**
2408      * Load a tree for the alignment if specified by parameter. Returns true if
2409      * a tree was loaded, else false.
2410      * 
2411      * @param alignFrame
2412      * @return
2413      */
2414     protected boolean loadTree(AlignFrame alignFrame)
2415     {
2416       boolean result = false;
2417       String treeFile = applet.getParameter("tree");
2418       if (treeFile == null)
2419       {
2420         treeFile = applet.getParameter("treeFile");
2421       }
2422
2423       if (treeFile != null)
2424       {
2425         try
2426         {
2427           treeFile = resolveFileProtocol(treeFile);
2428           NewickFile fin = new NewickFile(treeFile, protocol);
2429           fin.parse();
2430
2431           if (fin.getTree() != null)
2432           {
2433             alignFrame.loadTree(fin, treeFile);
2434             result = true;
2435             dbgMsg("Successfully imported tree.");
2436           }
2437           else
2438           {
2439             dbgMsg("Tree parameter did not resolve to a valid tree.");
2440           }
2441         } catch (Exception ex)
2442         {
2443           ex.printStackTrace();
2444         }
2445       }
2446       return result;
2447     }
2448
2449     /**
2450      * Discovers whether the given file is in the Applet Archive
2451      * 
2452      * @param f
2453      *          String
2454      * @return boolean
2455      */
2456     boolean inArchive(String f)
2457     {
2458       // This might throw a security exception in certain browsers
2459       // Netscape Communicator for instance.
2460       try
2461       {
2462         boolean rtn = (getClass().getResourceAsStream("/" + f) != null);
2463         if (debug)
2464         {
2465           System.err.println("Resource '" + f + "' was "
2466                   + (rtn ? "" : "not ") + "located by classloader.");
2467         }
2468         return rtn;
2469       } catch (Exception ex)
2470       {
2471         System.out.println("Exception checking resources: " + f + " " + ex);
2472         return false;
2473       }
2474     }
2475   }
2476
2477   /**
2478    * @return the default alignFrame acted on by the public applet methods. May
2479    *         return null with an error message on System.err indicating the
2480    *         fact.
2481    */
2482   public AlignFrame getDefaultTargetFrame()
2483   {
2484     if (currentAlignFrame != null)
2485     {
2486       return currentAlignFrame;
2487     }
2488     if (initialAlignFrame != null)
2489     {
2490       return initialAlignFrame;
2491     }
2492     System.err
2493             .println("Implementation error: Jalview Applet API cannot work out which AlignFrame to use.");
2494     return null;
2495   }
2496
2497   /**
2498    * separator used for separatorList
2499    */
2500   protected String separator = "" + ((char) 0x00AC); // the default used to be
2501                                                      // '|' but many sequence
2502                                                      // IDS include pipes.
2503
2504   /**
2505    * set to enable the URL based javascript execution mechanism
2506    */
2507   public boolean jsfallbackEnabled = false;
2508
2509   /**
2510    * parse the string into a list
2511    * 
2512    * @param list
2513    * @return elements separated by separator
2514    */
2515   public String[] separatorListToArray(String list)
2516   {
2517     return separatorListToArray(list, separator);
2518   }
2519
2520   /**
2521    * parse the string into a list
2522    * 
2523    * @param list
2524    * @param separator
2525    * @return elements separated by separator
2526    */
2527   public static String[] separatorListToArray(String list, String separator)
2528   {
2529     // TODO use StringUtils version (slightly different...)
2530     int seplen = separator.length();
2531     if (list == null || list.equals("") || list.equals(separator))
2532     {
2533       return null;
2534     }
2535     java.util.Vector jv = new Vector();
2536     int cp = 0, pos;
2537     while ((pos = list.indexOf(separator, cp)) > cp)
2538     {
2539       jv.addElement(list.substring(cp, pos));
2540       cp = pos + seplen;
2541     }
2542     if (cp < list.length())
2543     {
2544       String c = list.substring(cp);
2545       if (!c.equals(separator))
2546       {
2547         jv.addElement(c);
2548       }
2549     }
2550     if (jv.size() > 0)
2551     {
2552       String[] v = new String[jv.size()];
2553       for (int i = 0; i < v.length; i++)
2554       {
2555         v[i] = (String) jv.elementAt(i);
2556       }
2557       jv.removeAllElements();
2558       if (debug)
2559       {
2560         System.err.println("Array from '" + separator
2561                 + "' separated List:\n" + v.length);
2562         for (int i = 0; i < v.length; i++)
2563         {
2564           System.err.println("item " + i + " '" + v[i] + "'");
2565         }
2566       }
2567       return v;
2568     }
2569     if (debug)
2570     {
2571       System.err.println("Empty Array from '" + separator
2572               + "' separated List");
2573     }
2574     return null;
2575   }
2576
2577   /**
2578    * concatenate the list with separator
2579    * 
2580    * @param list
2581    * @return concatenated string
2582    */
2583   public String arrayToSeparatorList(String[] list)
2584   {
2585     return arrayToSeparatorList(list, separator);
2586   }
2587
2588   /**
2589    * concatenate the list with separator
2590    * 
2591    * @param list
2592    * @param separator
2593    * @return concatenated string
2594    */
2595   public static String arrayToSeparatorList(String[] list, String separator)
2596   {
2597     // TODO use StringUtils version
2598     StringBuffer v = new StringBuffer();
2599     if (list != null && list.length > 0)
2600     {
2601       for (int i = 0, iSize = list.length; i < iSize; i++)
2602       {
2603         if (list[i] != null)
2604         {
2605           if (i > 0)
2606           {
2607             v.append(separator);
2608           }
2609           v.append(list[i]);
2610         }
2611       }
2612       if (debug)
2613       {
2614         System.err.println("Returning '" + separator
2615                 + "' separated List:\n");
2616         System.err.println(v);
2617       }
2618       return v.toString();
2619     }
2620     if (debug)
2621     {
2622       System.err.println("Returning empty '" + separator
2623               + "' separated List\n");
2624     }
2625     return "" + separator;
2626   }
2627
2628   /*
2629    * (non-Javadoc)
2630    * 
2631    * @see jalview.bin.JalviewLiteJsApi#getFeatureGroups()
2632    */
2633   @Override
2634   public String getFeatureGroups()
2635   {
2636     String lst = arrayToSeparatorList(getDefaultTargetFrame()
2637             .getFeatureGroups());
2638     return lst;
2639   }
2640
2641   /*
2642    * (non-Javadoc)
2643    * 
2644    * @see
2645    * jalview.bin.JalviewLiteJsApi#getFeatureGroupsOn(jalview.appletgui.AlignFrame
2646    * )
2647    */
2648   @Override
2649   public String getFeatureGroupsOn(AlignFrame alf)
2650   {
2651     String lst = arrayToSeparatorList(alf.getFeatureGroups());
2652     return lst;
2653   }
2654
2655   /*
2656    * (non-Javadoc)
2657    * 
2658    * @see jalview.bin.JalviewLiteJsApi#getFeatureGroupsOfState(boolean)
2659    */
2660   @Override
2661   public String getFeatureGroupsOfState(boolean visible)
2662   {
2663     return arrayToSeparatorList(getDefaultTargetFrame()
2664             .getFeatureGroupsOfState(visible));
2665   }
2666
2667   /*
2668    * (non-Javadoc)
2669    * 
2670    * @see
2671    * jalview.bin.JalviewLiteJsApi#getFeatureGroupsOfStateOn(jalview.appletgui
2672    * .AlignFrame, boolean)
2673    */
2674   @Override
2675   public String getFeatureGroupsOfStateOn(AlignFrame alf, boolean visible)
2676   {
2677     return arrayToSeparatorList(alf.getFeatureGroupsOfState(visible));
2678   }
2679
2680   /*
2681    * (non-Javadoc)
2682    * 
2683    * @see jalview.bin.JalviewLiteJsApi#setFeatureGroupStateOn(jalview.appletgui.
2684    * AlignFrame, java.lang.String, boolean)
2685    */
2686   @Override
2687   public void setFeatureGroupStateOn(final AlignFrame alf,
2688           final String groups, boolean state)
2689   {
2690     final boolean st = state;// !(state==null || state.equals("") ||
2691     // state.toLowerCase().equals("false"));
2692     java.awt.EventQueue.invokeLater(new Runnable()
2693     {
2694       @Override
2695       public void run()
2696       {
2697         alf.setFeatureGroupState(separatorListToArray(groups), st);
2698       }
2699     });
2700   }
2701
2702   /*
2703    * (non-Javadoc)
2704    * 
2705    * @see jalview.bin.JalviewLiteJsApi#setFeatureGroupState(java.lang.String,
2706    * boolean)
2707    */
2708   @Override
2709   public void setFeatureGroupState(String groups, boolean state)
2710   {
2711     setFeatureGroupStateOn(getDefaultTargetFrame(), groups, state);
2712   }
2713
2714   /*
2715    * (non-Javadoc)
2716    * 
2717    * @see jalview.bin.JalviewLiteJsApi#getSeparator()
2718    */
2719   @Override
2720   public String getSeparator()
2721   {
2722     return separator;
2723   }
2724
2725   /*
2726    * (non-Javadoc)
2727    * 
2728    * @see jalview.bin.JalviewLiteJsApi#setSeparator(java.lang.String)
2729    */
2730   @Override
2731   public void setSeparator(String separator)
2732   {
2733     if (separator == null || separator.length() < 1)
2734     {
2735       // reset to default
2736       separator = "" + ((char) 0x00AC);
2737     }
2738     this.separator = separator;
2739     if (debug)
2740     {
2741       System.err.println("Default Separator now: '" + separator + "'");
2742     }
2743   }
2744
2745   /**
2746    * get boolean value of applet parameter 'name' and return default if
2747    * parameter is not set
2748    * 
2749    * @param name
2750    *          name of paremeter
2751    * @param def
2752    *          the value to return otherwise
2753    * @return true or false
2754    */
2755   public boolean getDefaultParameter(String name, boolean def)
2756   {
2757     String stn;
2758     if ((stn = getParameter(name)) == null)
2759     {
2760       return def;
2761     }
2762     if (TRUE.equalsIgnoreCase(stn))
2763     {
2764       return true;
2765     }
2766     return false;
2767   }
2768
2769   /*
2770    * (non-Javadoc)
2771    * 
2772    * @see jalview.bin.JalviewLiteJsApi#addPdbFile(jalview.appletgui.AlignFrame,
2773    * java.lang.String, java.lang.String, java.lang.String)
2774    */
2775   @Override
2776   public boolean addPdbFile(AlignFrame alFrame, String sequenceId,
2777           String pdbEntryString, String pdbFile)
2778   {
2779     return alFrame.addPdbFile(sequenceId, pdbEntryString, pdbFile);
2780   }
2781
2782   protected void setAlignPdbStructures(boolean alignPdbStructures)
2783   {
2784     this.alignPdbStructures = alignPdbStructures;
2785   }
2786
2787   public boolean isAlignPdbStructures()
2788   {
2789     return alignPdbStructures;
2790   }
2791
2792   @Override
2793   public void start()
2794   {
2795     // callInitCallback();
2796   }
2797
2798   private Hashtable<String, long[]> jshashes = new Hashtable<String, long[]>();
2799
2800   private Hashtable<String, Hashtable<String, String[]>> jsmessages = new Hashtable<String, Hashtable<String, String[]>>();
2801
2802   public void setJsMessageSet(String messageclass, String viewId,
2803           String[] colcommands)
2804   {
2805     Hashtable<String, String[]> msgset = jsmessages.get(messageclass);
2806     if (msgset == null)
2807     {
2808       msgset = new Hashtable<String, String[]>();
2809       jsmessages.put(messageclass, msgset);
2810     }
2811     msgset.put(viewId, colcommands);
2812     long[] l = new long[colcommands.length];
2813     for (int i = 0; i < colcommands.length; i++)
2814     {
2815       l[i] = colcommands[i].hashCode();
2816     }
2817     jshashes.put(messageclass + "|" + viewId, l);
2818   }
2819
2820   /*
2821    * (non-Javadoc)
2822    * 
2823    * @see jalview.bin.JalviewLiteJsApi#getJsMessage(java.lang.String,
2824    * java.lang.String)
2825    */
2826   @Override
2827   public String getJsMessage(String messageclass, String viewId)
2828   {
2829     Hashtable<String, String[]> msgset = jsmessages.get(messageclass);
2830     if (msgset != null)
2831     {
2832       String[] msgs = msgset.get(viewId);
2833       if (msgs != null)
2834       {
2835         for (int i = 0; i < msgs.length; i++)
2836         {
2837           if (msgs[i] != null)
2838           {
2839             String m = msgs[i];
2840             msgs[i] = null;
2841             return m;
2842           }
2843         }
2844       }
2845     }
2846     return "";
2847   }
2848
2849   public boolean isJsMessageSetChanged(String string, String string2,
2850           String[] colcommands)
2851   {
2852     long[] l = jshashes.get(string + "|" + string2);
2853     if (l == null && colcommands != null)
2854     {
2855       return true;
2856     }
2857     for (int i = 0; i < colcommands.length; i++)
2858     {
2859       if (l[i] != colcommands[i].hashCode())
2860       {
2861         return true;
2862       }
2863     }
2864     return false;
2865   }
2866
2867   private Vector jsExecQueue = new Vector();
2868
2869   public Vector getJsExecQueue()
2870   {
2871     return jsExecQueue;
2872   }
2873
2874   public void setExecutor(JSFunctionExec jsFunctionExec2)
2875   {
2876     jsFunctionExec = jsFunctionExec2;
2877   }
2878
2879   /**
2880    * return the given colour value parameter or the given default if parameter
2881    * not given
2882    * 
2883    * @param colparam
2884    * @param defcolour
2885    * @return
2886    */
2887   public Color getDefaultColourParameter(String colparam, Color defcolour)
2888   {
2889     String colprop = getParameter(colparam);
2890     if (colprop == null || colprop.trim().length() == 0)
2891     {
2892       return defcolour;
2893     }
2894     Color col = ColorUtils.parseColourString(colprop);
2895     if (col == null)
2896     {
2897       System.err.println("Couldn't parse '" + colprop
2898               + "' as a colour for " + colparam);
2899     }
2900     return (col == null) ? defcolour : col;
2901   }
2902
2903   public void openJalviewHelpUrl()
2904   {
2905     String helpUrl = getParameter("jalviewhelpurl");
2906     if (helpUrl == null || helpUrl.trim().length() < 5)
2907     {
2908       helpUrl = "http://www.jalview.org/help.html";
2909     }
2910     showURL(helpUrl, "HELP");
2911   }
2912
2913   /**
2914    * form a complete URL given a path to a resource and a reference location on
2915    * the same server
2916    * 
2917    * @param targetPath
2918    *          - an absolute path on the same server as localref or a document
2919    *          located relative to localref
2920    * @param localref
2921    *          - a URL on the same server as url
2922    * @return a complete URL for the resource located by url
2923    */
2924   private String resolveUrlForLocalOrAbsolute(String targetPath,
2925           URL localref)
2926   {
2927     String resolvedPath = "";
2928     if (targetPath.startsWith("/"))
2929     {
2930       String codebase = localref.toString();
2931       String localfile = localref.getFile();
2932       resolvedPath = codebase.substring(0,
2933               codebase.length() - localfile.length())
2934               + targetPath;
2935       return resolvedPath;
2936     }
2937
2938     /*
2939      * get URL path and strip off any trailing file e.g.
2940      * www.jalview.org/examples/index.html#applets?a=b is trimmed to
2941      * www.jalview.org/examples/
2942      */
2943     String urlPath = localref.toString();
2944     String directoryPath = urlPath;
2945     int lastSeparator = directoryPath.lastIndexOf("/");
2946     if (lastSeparator > 0)
2947     {
2948       directoryPath = directoryPath.substring(0, lastSeparator + 1);
2949     }
2950
2951     if (targetPath.startsWith("/"))
2952     {
2953       /*
2954        * construct absolute URL to a file on the server - this is not allowed?
2955        */
2956       // String localfile = localref.getFile();
2957       // resolvedPath = urlPath.substring(0,
2958       // urlPath.length() - localfile.length())
2959       // + targetPath;
2960       resolvedPath = directoryPath + targetPath.substring(1);
2961     }
2962     else
2963     {
2964       resolvedPath = directoryPath + targetPath;
2965     }
2966     if (debug)
2967     {
2968       System.err.println("resolveUrlForLocalOrAbsolute returning "
2969               + resolvedPath);
2970     }
2971     return resolvedPath;
2972   }
2973
2974   /**
2975    * open a URL in the browser - resolving it according to relative refs and
2976    * coping with javascript: protocol if necessary.
2977    * 
2978    * @param url
2979    * @param target
2980    */
2981   public void showURL(String url, String target)
2982   {
2983     try
2984     {
2985       if (url.indexOf(":") == -1)
2986       {
2987         // TODO: verify (Bas Vroling bug) prepend codebase or server URL to
2988         // form valid URL
2989         // Should really use docbase, not codebase.
2990         URL prepend;
2991         url = resolveUrlForLocalOrAbsolute(
2992                 url,
2993                 prepend = getDefaultParameter("resolvetocodebase", false) ? getCodeBase()
2994                         : getDocumentBase());
2995         if (debug)
2996         {
2997           System.err
2998                   .println("Show url (prepended "
2999                           + prepend
3000                           + " - toggle resolvetocodebase if code/docbase resolution is wrong): "
3001                           + url);
3002         }
3003       }
3004       else
3005       {
3006         if (debug)
3007         {
3008           System.err.println("Show url: " + url);
3009         }
3010       }
3011       if (url.indexOf("javascript:") == 0)
3012       {
3013         // no target for the javascript context
3014         getAppletContext().showDocument(new java.net.URL(url));
3015       }
3016       else
3017       {
3018         getAppletContext().showDocument(new java.net.URL(url), target);
3019       }
3020     } catch (Exception ex)
3021     {
3022       ex.printStackTrace();
3023     }
3024   }
3025
3026   /**
3027    * bind structures in a viewer to any matching sequences in an alignFrame (use
3028    * sequenceIds to limit scope of search to specific sequences)
3029    * 
3030    * @param alFrame
3031    * @param viewer
3032    * @param sequenceIds
3033    * @return TODO: consider making an exception structure for indicating when
3034    *         binding fails public SequenceStructureBinding
3035    *         addStructureViewInstance( AlignFrame alFrame, Object viewer, String
3036    *         sequenceIds) {
3037    * 
3038    *         if (sequenceIds != null && sequenceIds.length() > 0) { return
3039    *         alFrame.addStructureViewInstance(viewer,
3040    *         separatorListToArray(sequenceIds)); } else { return
3041    *         alFrame.addStructureViewInstance(viewer, null); } // return null; }
3042    */
3043 }