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