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