src/jalview/bin/JalviewLite.java

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