src/jalview/bin/JalviewLite.java

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