X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2FJalviewLite.java;h=7112381006241c2480f18e60be665277b35c9d09;hb=2e87920be1283b0dfab1e0dd5bf4127493c96241;hp=157c22bf6615bd9c42448f62b8af31eea26ff359;hpb=153dd62dc91da13ae732600e6ea55ddbe15eab39;p=jalview.git diff --git a/src/jalview/bin/JalviewLite.java b/src/jalview/bin/JalviewLite.java old mode 100755 new mode 100644 index 157c22b..7112381 --- a/src/jalview/bin/JalviewLite.java +++ b/src/jalview/bin/JalviewLite.java @@ -1,41 +1,59 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6) - * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * * Jalview is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - * + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * * Jalview is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.bin; -import jalview.api.SequenceStructureBinding; +import jalview.analysis.AlignmentUtils; +import jalview.api.StructureSelectionManagerProvider; import jalview.appletgui.AlignFrame; -import jalview.appletgui.AppletJmol; +import jalview.appletgui.AlignViewport; import jalview.appletgui.EmbmenuFrame; import jalview.appletgui.FeatureSettings; +import jalview.appletgui.SplitFrame; import jalview.datamodel.Alignment; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.AlignmentOrder; +import jalview.datamodel.ColumnSelection; import jalview.datamodel.PDBEntry; import jalview.datamodel.Sequence; +import jalview.datamodel.SequenceGroup; import jalview.datamodel.SequenceI; import jalview.io.AnnotationFile; import jalview.io.AppletFormatAdapter; import jalview.io.FileParse; import jalview.io.IdentifyFile; +import jalview.io.JPredFile; import jalview.io.JnetAnnotationMaker; +import jalview.io.NewickFile; +import jalview.javascript.JSFunctionExec; +import jalview.javascript.JalviewLiteJsApi; +import jalview.javascript.JsCallBack; +import jalview.structure.SelectionListener; +import jalview.structure.StructureSelectionManager; +import jalview.util.MessageManager; import java.applet.Applet; import java.awt.Button; import java.awt.Color; import java.awt.Component; +import java.awt.EventQueue; import java.awt.Font; import java.awt.Frame; import java.awt.Graphics; @@ -43,71 +61,84 @@ import java.awt.event.ActionEvent; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; import java.io.InputStreamReader; -import java.lang.reflect.Method; -import java.util.Enumeration; +import java.net.URL; +import java.util.Hashtable; +import java.util.List; import java.util.StringTokenizer; import java.util.Vector; +import netscape.javascript.JSObject; + /** * Jalview Applet. Runs in Java 1.18 runtime * * @author $author$ - * @version $Revision$ + * @version $Revision: 1.92 $ */ -public class JalviewLite extends Applet +public class JalviewLite extends Applet implements + StructureSelectionManagerProvider, JalviewLiteJsApi { + private static final String TRUE = "true"; + + private static final String FALSE = "false"; + + public StructureSelectionManager getStructureSelectionManager() + { + return StructureSelectionManager.getStructureSelectionManager(this); + } + // ///////////////////////////////////////// - // The following public methods maybe called + // The following public methods may be called // externally, eg via javascript in HTML page - /** - * @return String list of selected sequence IDs, each terminated by "¬" - * (¬) + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getSelectedSequences() */ public String getSelectedSequences() { return getSelectedSequencesFrom(getDefaultTargetFrame()); } - /** - * @param sep - * separator string or null for default - * @return String list of selected sequence IDs, each terminated by sep or - * ("¬" as default) + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getSelectedSequences(java.lang.String) */ public String getSelectedSequences(String sep) { return getSelectedSequencesFrom(getDefaultTargetFrame(), sep); } - /** - * @param alf - * alignframe containing selection - * @return String list of selected sequence IDs, each terminated by "¬" + /* + * (non-Javadoc) * + * @see + * jalview.bin.JalviewLiteJsApi#getSelectedSequencesFrom(jalview.appletgui + * .AlignFrame) */ public String getSelectedSequencesFrom(AlignFrame alf) { - return getSelectedSequencesFrom(alf, "¬"); + return getSelectedSequencesFrom(alf, separator); // ""+0x00AC); } - /** - * get list of selected sequence IDs separated by given separator + /* + * (non-Javadoc) * - * @param alf - * window containing selection - * @param sep - * separator string to use - default is "¬" - * @return String list of selected sequence IDs, each terminated by the given - * separator + * @see + * jalview.bin.JalviewLiteJsApi#getSelectedSequencesFrom(jalview.appletgui + * .AlignFrame, java.lang.String) */ public String getSelectedSequencesFrom(AlignFrame alf, String sep) { StringBuffer result = new StringBuffer(""); if (sep == null || sep.length() == 0) { - sep = "¬"; + sep = separator; // "+0x00AC; } if (alf.viewport.getSelectionGroup() != null) { @@ -124,46 +155,360 @@ public class JalviewLite extends Applet return result.toString(); } - /** - * get sequences selected in current alignFrame and return their alignment in - * format 'format' either with or without suffix - * - * @param alf - * - where selection is - * @param format - * - format of alignment file - * @param suffix - * - "true" to append /start-end string to each sequence ID - * @return selected sequences as flat file or empty string if there was no - * current selection + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#highlight(java.lang.String, + * java.lang.String, java.lang.String) + */ + public void highlight(String sequenceId, String position, + String alignedPosition) + { + highlightIn(getDefaultTargetFrame(), sequenceId, position, + alignedPosition); + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#highlightIn(jalview.appletgui.AlignFrame, + * java.lang.String, java.lang.String, java.lang.String) + */ + public void highlightIn(final AlignFrame alf, final String sequenceId, + final String position, final String alignedPosition) + { + // TODO: could try to highlight in all alignments if alf==null + jalview.analysis.SequenceIdMatcher matcher = new jalview.analysis.SequenceIdMatcher( + alf.viewport.getAlignment().getSequencesArray()); + final SequenceI sq = matcher.findIdMatch(sequenceId); + if (sq != null) + { + int apos = -1; + try + { + apos = new Integer(position).intValue(); + apos--; + } catch (NumberFormatException ex) + { + return; + } + final StructureSelectionManagerProvider me = this; + final int pos = apos; + // use vamsas listener to broadcast to all listeners in scope + if (alignedPosition != null + && (alignedPosition.trim().length() == 0 || alignedPosition + .toLowerCase().indexOf("false") > -1)) + { + java.awt.EventQueue.invokeLater(new Runnable() + { + @Override + public void run() + { + StructureSelectionManager.getStructureSelectionManager(me) + .mouseOverVamsasSequence(sq, sq.findIndex(pos), null); + } + }); + } + else + { + java.awt.EventQueue.invokeLater(new Runnable() + { + @Override + public void run() + { + StructureSelectionManager.getStructureSelectionManager(me) + .mouseOverVamsasSequence(sq, pos, null); + } + }); + } + } + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#select(java.lang.String, + * java.lang.String) + */ + public void select(String sequenceIds, String columns) + { + selectIn(getDefaultTargetFrame(), sequenceIds, columns, separator); + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#select(java.lang.String, + * java.lang.String, java.lang.String) + */ + public void select(String sequenceIds, String columns, String sep) + { + selectIn(getDefaultTargetFrame(), sequenceIds, columns, sep); + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#selectIn(jalview.appletgui.AlignFrame, + * java.lang.String, java.lang.String) + */ + public void selectIn(AlignFrame alf, String sequenceIds, String columns) + { + selectIn(alf, sequenceIds, columns, separator); + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#selectIn(jalview.appletgui.AlignFrame, + * java.lang.String, java.lang.String, java.lang.String) + */ + public void selectIn(final AlignFrame alf, String sequenceIds, + String columns, String sep) + { + if (sep == null || sep.length() == 0) + { + sep = separator; + } + else + { + if (debug) + { + System.err.println("Selecting region using separator string '" + + separator + "'"); + } + } + // deparse fields + String[] ids = separatorListToArray(sequenceIds, sep); + String[] cols = separatorListToArray(columns, sep); + final SequenceGroup sel = new SequenceGroup(); + final ColumnSelection csel = new ColumnSelection(); + AlignmentI al = alf.viewport.getAlignment(); + jalview.analysis.SequenceIdMatcher matcher = new jalview.analysis.SequenceIdMatcher( + alf.viewport.getAlignment().getSequencesArray()); + int start = 0, end = al.getWidth(), alw = al.getWidth(); + boolean seqsfound = true; + if (ids != null && ids.length > 0) + { + seqsfound = false; + for (int i = 0; i < ids.length; i++) + { + if (ids[i].trim().length() == 0) + { + continue; + } + SequenceI sq = matcher.findIdMatch(ids[i]); + if (sq != null) + { + seqsfound = true; + sel.addSequence(sq, false); + } + } + } + boolean inseqpos = false; + if (cols != null && cols.length > 0) + { + boolean seset = false; + for (int i = 0; i < cols.length; i++) + { + String cl = cols[i].trim(); + if (cl.length() == 0) + { + continue; + } + int p; + if ((p = cl.indexOf("-")) > -1) + { + int from = -1, to = -1; + try + { + from = new Integer(cl.substring(0, p)).intValue(); + from--; + } catch (NumberFormatException ex) + { + System.err + .println("ERROR: Couldn't parse first integer in range element column selection string '" + + cl + "' - format is 'from-to'"); + return; + } + try + { + to = new Integer(cl.substring(p + 1)).intValue(); + to--; + } catch (NumberFormatException ex) + { + System.err + .println("ERROR: Couldn't parse second integer in range element column selection string '" + + cl + "' - format is 'from-to'"); + return; + } + if (from >= 0 && to >= 0) + { + // valid range + if (from < to) + { + int t = to; + to = from; + to = t; + } + if (!seset) + { + start = from; + end = to; + seset = true; + } + else + { + // comment to prevent range extension + if (start > from) + { + start = from; + } + if (end < to) + { + end = to; + } + } + for (int r = from; r <= to; r++) + { + if (r >= 0 && r < alw) + { + csel.addElement(r); + } + } + if (debug) + { + System.err.println("Range '" + cl + "' deparsed as [" + from + + "," + to + "]"); + } + } + else + { + System.err.println("ERROR: Invalid Range '" + cl + + "' deparsed as [" + from + "," + to + "]"); + } + } + else + { + int r = -1; + try + { + r = new Integer(cl).intValue(); + r--; + } catch (NumberFormatException ex) + { + if (cl.toLowerCase().equals("sequence")) + { + // we are in the dataset sequence's coordinate frame. + inseqpos = true; + } + else + { + System.err + .println("ERROR: Couldn't parse integer from point selection element of column selection string '" + + cl + "'"); + return; + } + } + if (r >= 0 && r <= alw) + { + if (!seset) + { + start = r; + end = r; + seset = true; + } + else + { + // comment to prevent range extension + if (start > r) + { + start = r; + } + if (end < r) + { + end = r; + } + } + csel.addElement(r); + if (debug) + { + System.err.println("Point selection '" + cl + + "' deparsed as [" + r + "]"); + } + } + else + { + System.err.println("ERROR: Invalid Point selection '" + cl + + "' deparsed as [" + r + "]"); + } + } + } + } + if (seqsfound) + { + // we only propagate the selection when it was the null selection, or the + // given sequences were found in the alignment. + if (inseqpos && sel.getSize() > 0) + { + // assume first sequence provides reference frame ? + SequenceI rs = sel.getSequenceAt(0); + start = rs.findIndex(start); + end = rs.findIndex(end); + if (csel != null) + { + List cs = csel.getSelected(); + csel.clear(); + for (Integer selectedCol : cs) + { + csel.addElement(rs.findIndex(selectedCol)); + } + } + } + sel.setStartRes(start); + sel.setEndRes(end); + EventQueue.invokeLater(new Runnable() + { + @Override + public void run() + { + alf.select(sel, csel); + } + }); + } + } + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getSelectedSequencesAsAlignment(java.lang. + * String, java.lang.String) */ public String getSelectedSequencesAsAlignment(String format, String suffix) { - return getSelectedSequencesAsAlignmentFrom(currentAlignFrame, format, - suffix); + return getSelectedSequencesAsAlignmentFrom(getDefaultTargetFrame(), + format, suffix); } - /** - * get sequences selected in alf and return their alignment in format 'format' - * either with or without suffix - * - * @param alf - * - where selection is - * @param format - * - format of alignment file - * @param suffix - * - "true" to append /start-end string to each sequence ID - * @return selected sequences as flat file or empty string if there was no - * current selection + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getSelectedSequencesAsAlignmentFrom(jalview + * .appletgui.AlignFrame, java.lang.String, java.lang.String) */ public String getSelectedSequencesAsAlignmentFrom(AlignFrame alf, String format, String suffix) { try { - boolean seqlimits = suffix.equalsIgnoreCase("true"); + boolean seqlimits = suffix.equalsIgnoreCase(TRUE); if (alf.viewport.getSelectionGroup() != null) { + // JBPNote: getSelectionAsNewSequence behaviour has changed - this + // method now returns a full copy of sequence data + // TODO consider using getSequenceSelection instead here String reply = new AppletFormatAdapter().formatSequences(format, new Alignment(alf.viewport.getSelectionAsNewSequence()), seqlimits); @@ -177,27 +522,172 @@ public class JalviewLite extends Applet return ""; } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getAlignmentOrder() + */ + public String getAlignmentOrder() + { + return getAlignmentOrderFrom(getDefaultTargetFrame()); + } + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getAlignmentOrderFrom(jalview.appletgui.AlignFrame + * ) + */ + public String getAlignmentOrderFrom(AlignFrame alf) + { + return getAlignmentOrderFrom(alf, separator); + } + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getAlignmentOrderFrom(jalview.appletgui.AlignFrame + * , java.lang.String) + */ + public String getAlignmentOrderFrom(AlignFrame alf, String sep) + { + AlignmentI alorder = alf.getAlignViewport().getAlignment(); + String[] order = new String[alorder.getHeight()]; + for (int i = 0; i < order.length; i++) + { + order[i] = alorder.getSequenceAt(i).getName(); + } + return arrayToSeparatorList(order); + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#orderBy(java.lang.String, + * java.lang.String) + */ + public String orderBy(String order, String undoName) + { + return orderBy(order, undoName, separator); + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#orderBy(java.lang.String, + * java.lang.String, java.lang.String) + */ + public String orderBy(String order, String undoName, String sep) + { + return orderAlignmentBy(getDefaultTargetFrame(), order, undoName, sep); + } + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#orderAlignmentBy(jalview.appletgui.AlignFrame, + * java.lang.String, java.lang.String, java.lang.String) + */ + public String orderAlignmentBy(AlignFrame alf, String order, + String undoName, String sep) + { + String[] ids = separatorListToArray(order, sep); + SequenceI[] sqs = null; + if (ids != null && ids.length > 0) + { + jalview.analysis.SequenceIdMatcher matcher = new jalview.analysis.SequenceIdMatcher( + alf.viewport.getAlignment().getSequencesArray()); + int s = 0; + sqs = new SequenceI[ids.length]; + for (int i = 0; i < ids.length; i++) + { + if (ids[i].trim().length() == 0) + { + continue; + } + SequenceI sq = matcher.findIdMatch(ids[i]); + if (sq != null) + { + sqs[s++] = sq; + } + } + if (s > 0) + { + SequenceI[] sqq = new SequenceI[s]; + System.arraycopy(sqs, 0, sqq, 0, s); + sqs = sqq; + } + else + { + sqs = null; + } + } + if (sqs == null) + { + return ""; + } + ; + final AlignmentOrder aorder = new AlignmentOrder(sqs); + + if (undoName != null && undoName.trim().length() == 0) + { + undoName = null; + } + final String _undoName = undoName; + // TODO: deal with synchronization here: cannot raise any events until after + // this has returned. + return alf.sortBy(aorder, _undoName) ? TRUE : ""; + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getAlignment(java.lang.String) + */ public String getAlignment(String format) { - return getAlignmentFrom(getDefaultTargetFrame(), format, "true"); + return getAlignmentFrom(getDefaultTargetFrame(), format, TRUE); } + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getAlignmentFrom(jalview.appletgui.AlignFrame, + * java.lang.String) + */ public String getAlignmentFrom(AlignFrame alf, String format) { - return getAlignmentFrom(alf, format, "true"); + return getAlignmentFrom(alf, format, TRUE); } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getAlignment(java.lang.String, + * java.lang.String) + */ public String getAlignment(String format, String suffix) { return getAlignmentFrom(getDefaultTargetFrame(), format, suffix); } + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getAlignmentFrom(jalview.appletgui.AlignFrame, + * java.lang.String, java.lang.String) + */ public String getAlignmentFrom(AlignFrame alf, String format, String suffix) { try { - boolean seqlimits = suffix.equalsIgnoreCase("true"); + boolean seqlimits = suffix.equalsIgnoreCase(TRUE); String reply = new AppletFormatAdapter().formatSequences(format, alf.viewport.getAlignment(), seqlimits); @@ -209,15 +699,27 @@ public class JalviewLite extends Applet } } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#loadAnnotation(java.lang.String) + */ public void loadAnnotation(String annotation) { loadAnnotationFrom(getDefaultTargetFrame(), annotation); } + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#loadAnnotationFrom(jalview.appletgui.AlignFrame + * , java.lang.String) + */ public void loadAnnotationFrom(AlignFrame alf, String annotation) { - if (new AnnotationFile().readAnnotationFile(alf.getAlignViewport() - .getAlignment(), annotation, AppletFormatAdapter.PASTE)) + if (new AnnotationFile().annotateAlignmentView(alf.getAlignViewport(), + annotation, AppletFormatAdapter.PASTE)) { alf.alignPanel.fontChanged(); alf.alignPanel.setScrollValues(0, 0); @@ -228,57 +730,124 @@ public class JalviewLite extends Applet } } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#loadAnnotation(java.lang.String) + */ + public void loadFeatures(String features, boolean autoenabledisplay) + { + loadFeaturesFrom(getDefaultTargetFrame(), features, autoenabledisplay); + } + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#loadAnnotationFrom(jalview.appletgui.AlignFrame + * , java.lang.String) + */ + public boolean loadFeaturesFrom(AlignFrame alf, String features, + boolean autoenabledisplay) + { + return alf.parseFeaturesFile(features, AppletFormatAdapter.PASTE, + autoenabledisplay); + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getFeatures(java.lang.String) + */ public String getFeatures(String format) { return getFeaturesFrom(getDefaultTargetFrame(), format); } + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getFeaturesFrom(jalview.appletgui.AlignFrame, + * java.lang.String) + */ public String getFeaturesFrom(AlignFrame alf, String format) { return alf.outputFeatures(false, format); } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getAnnotation() + */ public String getAnnotation() { return getAnnotationFrom(getDefaultTargetFrame()); } + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getAnnotationFrom(jalview.appletgui.AlignFrame + * ) + */ public String getAnnotationFrom(AlignFrame alf) { return alf.outputAnnotations(false); } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#newView() + */ public AlignFrame newView() { return newViewFrom(getDefaultTargetFrame()); } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#newView(java.lang.String) + */ public AlignFrame newView(String name) { return newViewFrom(getDefaultTargetFrame(), name); } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#newViewFrom(jalview.appletgui.AlignFrame) + */ public AlignFrame newViewFrom(AlignFrame alf) { return alf.newView(null); } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#newViewFrom(jalview.appletgui.AlignFrame, + * java.lang.String) + */ public AlignFrame newViewFrom(AlignFrame alf, String name) { return alf.newView(name); } - /** + /* + * (non-Javadoc) * - * @param text - * alignment file as a string - * @param title - * window title - * @return null or new alignment frame + * @see jalview.bin.JalviewLiteJsApi#loadAlignment(java.lang.String, + * java.lang.String) */ public AlignFrame loadAlignment(String text, String title) { - Alignment al = null; + AlignmentI al = null; String format = new IdentifyFile().Identify(text, AppletFormatAdapter.PASTE); @@ -297,6 +866,376 @@ public class JalviewLite extends Applet return null; } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#setMouseoverListener(java.lang.String) + */ + public void setMouseoverListener(String listener) + { + setMouseoverListener(currentAlignFrame, listener); + } + + private Vector javascriptListeners = new Vector(); + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#setMouseoverListener(jalview.appletgui.AlignFrame + * , java.lang.String) + */ + public void setMouseoverListener(AlignFrame af, String listener) + { + if (listener != null) + { + listener = listener.trim(); + if (listener.length() == 0) + { + System.err + .println("jalview Javascript error: Ignoring empty function for mouseover listener."); + return; + } + } + jalview.javascript.MouseOverListener mol = new jalview.javascript.MouseOverListener( + this, af, listener); + javascriptListeners.addElement(mol); + StructureSelectionManager.getStructureSelectionManager(this) + .addStructureViewerListener(mol); + if (debug) + { + System.err.println("Added a mouseover listener for " + + ((af == null) ? "All frames" : "Just views for " + + af.getAlignViewport().getSequenceSetId())); + System.err.println("There are now " + javascriptListeners.size() + + " listeners in total."); + } + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#setSelectionListener(java.lang.String) + */ + public void setSelectionListener(String listener) + { + setSelectionListener(null, listener); + } + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#setSelectionListener(jalview.appletgui.AlignFrame + * , java.lang.String) + */ + public void setSelectionListener(AlignFrame af, String listener) + { + if (listener != null) + { + listener = listener.trim(); + if (listener.length() == 0) + { + System.err + .println("jalview Javascript error: Ignoring empty function for selection listener."); + return; + } + } + jalview.javascript.JsSelectionSender mol = new jalview.javascript.JsSelectionSender( + this, af, listener); + javascriptListeners.addElement(mol); + StructureSelectionManager.getStructureSelectionManager(this) + .addSelectionListener(mol); + if (debug) + { + System.err.println("Added a selection listener for " + + ((af == null) ? "All frames" : "Just views for " + + af.getAlignViewport().getSequenceSetId())); + System.err.println("There are now " + javascriptListeners.size() + + " listeners in total."); + } + } + + /** + * Callable from javascript to register a javascript function to pass events + * to a structure viewer. + * + * @param listener + * the name of a javascript function + * @param modelSet + * a token separated list of PDB file names listened for + * @see jalview.bin.JalviewLiteJsApi#setStructureListener(java.lang.String, + * java.lang.String) + */ + public void setStructureListener(String listener, String modelSet) + { + if (listener != null) + { + listener = listener.trim(); + if (listener.length() == 0) + { + System.err + .println("jalview Javascript error: Ignoring empty function for selection listener."); + return; + } + } + jalview.javascript.MouseOverStructureListener mol = new jalview.javascript.MouseOverStructureListener( + this, listener, separatorListToArray(modelSet)); + javascriptListeners.addElement(mol); + StructureSelectionManager.getStructureSelectionManager(this) + .addStructureViewerListener(mol); + if (debug) + { + System.err.println("Added a javascript structure viewer listener '" + + listener + "'"); + System.err.println("There are now " + javascriptListeners.size() + + " listeners in total."); + } + } + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#removeJavascriptListener(jalview.appletgui + * .AlignFrame, java.lang.String) + */ + public void removeJavascriptListener(AlignFrame af, String listener) + { + if (listener != null) + { + listener = listener.trim(); + if (listener.length() == 0) + { + listener = null; + } + } + boolean rprt = false; + for (int ms = 0, msSize = javascriptListeners.size(); ms < msSize;) + { + Object lstn = javascriptListeners.elementAt(ms); + JsCallBack lstner = (JsCallBack) lstn; + if ((af == null || lstner.getAlignFrame() == af) + && (listener == null || lstner.getListenerFunction().equals( + listener))) + { + javascriptListeners.removeElement(lstner); + msSize--; + if (lstner instanceof SelectionListener) + { + StructureSelectionManager.getStructureSelectionManager(this) + .removeSelectionListener((SelectionListener) lstner); + } + else + { + StructureSelectionManager.getStructureSelectionManager(this) + .removeStructureViewerListener(lstner, null); + } + rprt = debug; + if (debug) + { + System.err.println("Removed listener '" + listener + "'"); + } + } + else + { + ms++; + } + } + if (rprt) + { + System.err.println("There are now " + javascriptListeners.size() + + " listeners in total."); + } + } + + public void stop() + { + System.err.println("Applet " + getName() + " stop()."); + tidyUp(); + } + + public void destroy() + { + System.err.println("Applet " + getName() + " destroy()."); + tidyUp(); + } + + private void tidyUp() + { + removeAll(); + if (currentAlignFrame != null && currentAlignFrame.viewport != null + && currentAlignFrame.viewport.applet != null) + { + AlignViewport av = currentAlignFrame.viewport; + currentAlignFrame.closeMenuItem_actionPerformed(); + av.applet = null; + currentAlignFrame = null; + } + if (javascriptListeners != null) + { + while (javascriptListeners.size() > 0) + { + jalview.javascript.JSFunctionExec mol = javascriptListeners + .elementAt(0); + javascriptListeners.removeElement(mol); + if (mol instanceof SelectionListener) + { + StructureSelectionManager.getStructureSelectionManager(this) + .removeSelectionListener((SelectionListener) mol); + } + else + { + StructureSelectionManager.getStructureSelectionManager(this) + .removeStructureViewerListener(mol, null); + } + mol.jvlite = null; + } + } + if (jsFunctionExec != null) + { + jsFunctionExec.stopQueue(); + jsFunctionExec.jvlite = null; + } + initialAlignFrame = null; + jsFunctionExec = null; + javascriptListeners = null; + StructureSelectionManager.release(this); + } + + private jalview.javascript.JSFunctionExec jsFunctionExec; + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#mouseOverStructure(java.lang.String, + * java.lang.String, java.lang.String) + */ + public void mouseOverStructure(final String pdbResNum, + final String chain, final String pdbfile) + { + final StructureSelectionManagerProvider me = this; + java.awt.EventQueue.invokeLater(new Runnable() + { + @Override + public void run() + { + try + { + StructureSelectionManager.getStructureSelectionManager(me) + .mouseOverStructure(new Integer(pdbResNum).intValue(), + chain, pdbfile); + if (debug) + { + System.err.println("mouseOver for '" + pdbResNum + + "' in chain '" + chain + "' in structure '" + pdbfile + + "'"); + } + } catch (NumberFormatException e) + { + System.err.println("Ignoring invalid residue number string '" + + pdbResNum + "'"); + } + + } + }); + } + + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#scrollViewToIn(jalview.appletgui.AlignFrame, + * java.lang.String, java.lang.String) + */ + public void scrollViewToIn(final AlignFrame alf, final String topRow, + final String leftHandColumn) + { + java.awt.EventQueue.invokeLater(new Runnable() + { + @Override + public void run() + { + try + { + alf.scrollTo(new Integer(topRow).intValue(), new Integer( + leftHandColumn).intValue()); + + } catch (Exception ex) + { + System.err.println("Couldn't parse integer arguments (topRow='" + + topRow + "' and leftHandColumn='" + leftHandColumn + + "')"); + ex.printStackTrace(); + } + } + }); + } + + /* + * (non-Javadoc) + * + * @see + * jalview.javascript.JalviewLiteJsApi#scrollViewToRowIn(jalview.appletgui + * .AlignFrame, java.lang.String) + */ + @Override + public void scrollViewToRowIn(final AlignFrame alf, final String topRow) + { + + java.awt.EventQueue.invokeLater(new Runnable() + { + @Override + public void run() + { + try + { + alf.scrollToRow(new Integer(topRow).intValue()); + + } catch (Exception ex) + { + System.err.println("Couldn't parse integer arguments (topRow='" + + topRow + "')"); + ex.printStackTrace(); + } + + } + }); + } + + /* + * (non-Javadoc) + * + * @see + * jalview.javascript.JalviewLiteJsApi#scrollViewToColumnIn(jalview.appletgui + * .AlignFrame, java.lang.String) + */ + @Override + public void scrollViewToColumnIn(final AlignFrame alf, + final String leftHandColumn) + { + java.awt.EventQueue.invokeLater(new Runnable() + { + + @Override + public void run() + { + try + { + alf.scrollToColumn(new Integer(leftHandColumn).intValue()); + + } catch (Exception ex) + { + System.err + .println("Couldn't parse integer arguments (leftHandColumn='" + + leftHandColumn + "')"); + ex.printStackTrace(); + } + } + }); + + } + // ////////////////////////////////////////////// // ////////////////////////////////////////////// @@ -308,7 +1247,10 @@ public class JalviewLite extends Applet String file = "No file"; - Button launcher = new Button("Start Jalview"); + String file2 = null; + + Button launcher = new Button( + MessageManager.getString("label.start_jalview")); /** * The currentAlignFrame is static, it will change if and when the user @@ -316,7 +1258,7 @@ public class JalviewLite extends Applet * AlignFrame if the applet is started as embedded on the page and then * afterwards a new view is created. */ - public static AlignFrame currentAlignFrame = null; + public AlignFrame currentAlignFrame = null; /** * This is the first frame to be displayed, and does not change. API calls @@ -334,11 +1276,17 @@ public class JalviewLite extends Applet public boolean jmolAvailable = false; - private boolean alignPdbStructures=false; + private boolean alignPdbStructures = false; + + /** + * use an external structure viewer exclusively (no jmols or MCViews will be + * opened by JalviewLite itself) + */ + public boolean useXtrnalSviewer = false; public static boolean debug = false; - static String builddate = null, version = null; + static String builddate = null, version = null, installation = null; private static void initBuildDetails() { @@ -346,6 +1294,7 @@ public class JalviewLite extends Applet { builddate = "unknown"; version = "test"; + installation = "applet"; java.net.URL url = JalviewLite.class .getResource("/.build_properties"); if (url != null) @@ -365,6 +1314,10 @@ public class JalviewLite extends Applet { builddate = line.substring(line.indexOf("=") + 1); } + if (line.indexOf("INSTALLATION") > -1) + { + installation = line.substring(line.indexOf("=") + 1); + } } } catch (Exception ex) { @@ -380,32 +1333,60 @@ public class JalviewLite extends Applet return builddate; } + public static String getInstallation() + { + initBuildDetails(); + return installation; + } + public static String getVersion() { initBuildDetails(); return version; } + // public JSObject scriptObject = null; + /** * init method for Jalview Applet */ + @Override public void init() { + debug = TRUE.equalsIgnoreCase(getParameter("debug")); + try + { + if (debug) + { + System.err.println("Applet context is '" + + getAppletContext().getClass().toString() + "'"); + } + JSObject scriptObject = JSObject.getWindow(this); + if (debug && scriptObject != null) + { + System.err.println("Applet has Javascript callback support."); + } - /** - * turn on extra applet debugging - */ - String dbg = getParameter("debug"); - if (dbg != null) + } catch (Exception ex) { - debug = dbg.toLowerCase().equals("true"); + System.err + .println("Warning: No JalviewLite javascript callbacks available."); + if (debug) + { + ex.printStackTrace(); + } } + if (debug) { - System.err.println("JalviewLite Version " + getVersion()); System.err.println("Build Date : " + getBuildDate()); - + System.err.println("Installation : " + getInstallation()); + } + String externalsviewer = getParameter("externalstructureviewer"); + if (externalsviewer != null) + { + useXtrnalSviewer = externalsviewer.trim().toLowerCase().equals(TRUE); } /** * if true disable the check for jmol @@ -413,7 +1394,7 @@ public class JalviewLite extends Applet String chkforJmol = getParameter("nojmol"); if (chkforJmol != null) { - checkForJmol = !chkforJmol.equals("true"); + checkForJmol = !chkforJmol.equals(TRUE); } /** * get the separator parameter if present @@ -432,7 +1413,8 @@ public class JalviewLite extends Applet else { throw new Error( - "Invalid separator parameter - must be non-zero length"); + MessageManager + .getString("error.invalid_separator_parameter")); } } int r = 255; @@ -454,14 +1436,13 @@ public class JalviewLite extends Applet b = 255; } } - param = getParameter("label"); if (param != null) { launcher.setLabel(param); } - this.setBackground(new Color(r, g, b)); + setBackground(new Color(r, g, b)); file = getParameter("file"); @@ -480,38 +1461,40 @@ public class JalviewLite extends Applet file = data.toString(); } } + if (getDefaultParameter("enableSplitFrame", true)) + { + file2 = getParameter("file2"); + } - final JalviewLite applet = this; - if (getParameter("embedded") != null - && getParameter("embedded").equalsIgnoreCase("true")) + embedded = TRUE.equalsIgnoreCase(getParameter("embedded")); + if (embedded) { - // Launch as embedded applet in page - embedded = true; - LoadingThread loader = new LoadingThread(file, applet); + LoadingThread loader = new LoadingThread(file, file2, this); loader.start(); } else if (file != null) { - if (getParameter("showbutton") == null - || !getParameter("showbutton").equalsIgnoreCase("false")) + /* + * Start the applet immediately or show a button to start it + */ + if (FALSE.equalsIgnoreCase(getParameter("showbutton"))) + { + LoadingThread loader = new LoadingThread(file, file2, this); + loader.start(); + } + else { - // Add the JalviewLite 'Button' to the page add(launcher); launcher.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(ActionEvent e) { - LoadingThread loader = new LoadingThread(file, applet); + LoadingThread loader = new LoadingThread(file, file2, + JalviewLite.this); loader.start(); } }); } - else - { - // Open jalviewLite immediately. - LoadingThread loader = new LoadingThread(file, applet); - loader.start(); - } } else { @@ -519,6 +1502,88 @@ public class JalviewLite extends Applet // still be called to open new alignments. file = "NO FILE"; fileFound = false; + callInitCallback(); + } + } + + private void initLiveConnect() + { + // try really hard to get the liveConnect thing working + boolean notFailed = false; + int tries = 0; + while (!notFailed && tries < 10) + { + if (tries > 0) + { + System.err.println("LiveConnect request thread going to sleep."); + } + try + { + Thread.sleep(700 * (1 + tries)); + } catch (InterruptedException q) + { + } + ; + if (tries++ > 0) + { + System.err.println("LiveConnect request thread woken up."); + } + try + { + JSObject scriptObject = JSObject.getWindow(this); + if (scriptObject.eval("navigator") != null) + { + notFailed = true; + } + } catch (Exception jsex) + { + System.err.println("Attempt " + tries + + " to access LiveConnect javascript failed."); + } + } + } + + private void callInitCallback() + { + String initjscallback = getParameter("oninit"); + if (initjscallback == null) + { + return; + } + initjscallback = initjscallback.trim(); + if (initjscallback.length() > 0) + { + JSObject scriptObject = null; + try + { + scriptObject = JSObject.getWindow(this); + } catch (Exception ex) + { + } + ; + // try really hard to let the browser plugin know we want liveconnect + initLiveConnect(); + + if (scriptObject != null) + { + try + { + // do onInit with the JS executor thread + new JSFunctionExec(this).executeJavascriptFunction(true, + initjscallback, null, "Calling oninit callback '" + + initjscallback + "'."); + } catch (Exception e) + { + System.err.println("Exception when executing _oninit callback '" + + initjscallback + "'."); + e.printStackTrace(); + } + } + else + { + System.err.println("Not executing _oninit callback '" + + initjscallback + "' - no scripting allowed."); + } } } @@ -548,11 +1613,15 @@ public class JalviewLite extends Applet { if (frame instanceof AlignFrame) { + AlignViewport vp = ((AlignFrame) frame).viewport; ((AlignFrame) frame).closeMenuItem_actionPerformed(); - } - if (currentAlignFrame == frame) - { - currentAlignFrame = null; + if (vp.applet.currentAlignFrame == frame) + { + vp.applet.currentAlignFrame = null; + } + vp.applet = null; + vp = null; + } lastFrameX -= 40; lastFrameY -= 40; @@ -568,7 +1637,7 @@ public class JalviewLite extends Applet { if (frame instanceof AlignFrame) { - currentAlignFrame = (AlignFrame) frame; + ((AlignFrame) frame).viewport.applet.currentAlignFrame = (AlignFrame) frame; if (debug) { System.err.println("Activated window " + frame); @@ -609,16 +1678,43 @@ public class JalviewLite extends Applet g.setColor(Color.cyan); g.fillRect(0, 0, getSize().width, getSize().height); g.setColor(Color.red); - g.drawString("Jalview can't open file", 5, 15); + g.drawString( + MessageManager.getString("label.jalview_cannot_open_file"), + 5, 15); g.drawString("\"" + file + "\"", 5, 30); } else if (embedded) { g.setColor(Color.black); g.setFont(new Font("Arial", Font.BOLD, 24)); - g.drawString("Jalview Applet", 50, this.getSize().height / 2 - 30); - g.drawString("Loading Data...", 50, this.getSize().height / 2); + g.drawString(MessageManager.getString("label.jalview_applet"), 50, + getSize().height / 2 - 30); + g.drawString(MessageManager.getString("label.loading_data") + "...", + 50, getSize().height / 2); + } + } + + /** + * get all components associated with the applet of the given type + * + * @param class1 + * @return + */ + public Vector getAppletWindow(Class class1) + { + Vector wnds = new Vector(); + Component[] cmp = getComponents(); + if (cmp != null) + { + for (int i = 0; i < cmp.length; i++) + { + if (class1.isAssignableFrom(cmp[i].getClass())) + { + wnds.addElement(cmp); + } + } } + return wnds; } class LoadJmolThread extends Thread @@ -672,27 +1768,19 @@ public class JalviewLite extends Applet class LoadingThread extends Thread { /** - * State variable: File source - */ - String file; - - /** * State variable: protocol for access to file source */ String protocol; - /** - * State variable: format of file source - */ - String format; + String _file; // alignment file or URL spec - String _file; + String _file2; // second alignment file or URL spec JalviewLite applet; private void dbgMsg(String msg) { - if (applet.debug) + if (JalviewLite.debug) { System.err.println(msg); } @@ -725,9 +1813,10 @@ public class JalviewLite extends Applet return file; } - public LoadingThread(String _file, JalviewLite _applet) + public LoadingThread(String file, String file2, JalviewLite _applet) { - this._file = _file; + this._file = file; + this._file2 = file2; applet = _applet; } @@ -744,24 +1833,128 @@ public class JalviewLite extends Applet } catch (Exception e) { } - ; } startLoading(); + // applet.callInitCallback(); } + /** + * Load the alignment and any related files as specified by applet + * parameters + */ private void startLoading() { - AlignFrame newAlignFrame; dbgMsg("Loading thread started with:\n>>file\n" + _file + ">>endfile"); - file = setProtocolState(_file); - format = new jalview.io.IdentifyFile().Identify(file, protocol); - dbgMsg("File identified as '" + format + "'"); dbgMsg("Loading started."); - Alignment al = null; + + AlignFrame newAlignFrame = readAlignment(_file); + AlignFrame newAlignFrame2 = readAlignment(_file2); + if (newAlignFrame != null) + { + addToDisplay(newAlignFrame, newAlignFrame2); + loadTree(newAlignFrame); + + loadScoreFile(newAlignFrame); + + loadFeatures(newAlignFrame); + + loadAnnotations(newAlignFrame); + + loadJnetFile(newAlignFrame); + + loadPdbFiles(newAlignFrame); + } + else + { + fileFound = false; + applet.remove(launcher); + applet.repaint(); + } + callInitCallback(); + } + + /** + * Add an AlignFrame to the display; or if two are provided, a SplitFrame. + * + * @param af + * @param af2 + */ + public void addToDisplay(AlignFrame af, AlignFrame af2) + { + if (af2 != null) + { + AlignmentI al1 = af.viewport.getAlignment(); + AlignmentI al2 = af2.viewport.getAlignment(); + AlignmentI cdna = al1.isNucleotide() ? al1 : al2; + AlignmentI prot = al1.isNucleotide() ? al2 : al1; + if (AlignmentUtils.mapProteinAlignmentToCdna(prot, cdna)) + { + al2.alignAs(al1); + SplitFrame sf = new SplitFrame(af, af2); + sf.addToDisplay(embedded, JalviewLite.this); + return; + } + else + { + String msg = "Could not map any sequence in " + af2.getTitle() + + " as " + + (al1.isNucleotide() ? "protein product" : "cDNA") + + " for " + af.getTitle(); + System.err.println(msg); + } + } + + af.addToDisplay(embedded); + } + + /** + * Read the alignment file (from URL, text 'paste', or archive by + * classloader). + * + * @return + */ + protected AlignFrame readAlignment(String fileParam) + { + if (fileParam == null) + { + return null; + } + String resolvedFile = setProtocolState(fileParam); + String format = new IdentifyFile().Identify(resolvedFile, protocol); + dbgMsg("File identified as '" + format + "'"); + AlignmentI al = null; try { - al = new AppletFormatAdapter().readFile(file, protocol, format); + al = new AppletFormatAdapter().readFile(resolvedFile, protocol, + format); + if ((al != null) && (al.getHeight() > 0)) + { + dbgMsg("Successfully loaded file."); + al.setDataset(null); + AlignFrame newAlignFrame = new AlignFrame(al, applet, + resolvedFile, embedded, false); + newAlignFrame.setTitle(resolvedFile); + if (initialAlignFrame == null) + { + initialAlignFrame = newAlignFrame; + } + // update the focus. + currentAlignFrame = newAlignFrame; + + if (protocol == AppletFormatAdapter.PASTE) + { + newAlignFrame.setTitle(MessageManager.formatMessage( + "label.sequences_from", new Object[] { applet + .getDocumentBase().toString() })); + } + + newAlignFrame.statusBar.setText(MessageManager.formatMessage( + "label.successfully_loaded_file", + new Object[] { resolvedFile })); + + return newAlignFrame; + } } catch (java.io.IOException ex) { dbgMsg("File load exception."); @@ -770,9 +1963,9 @@ public class JalviewLite extends Applet { try { - FileParse fp = new FileParse(file, protocol); + FileParse fp = new FileParse(resolvedFile, protocol); String ln = null; - dbgMsg(">>>Dumping contents of '" + file + "' " + "(" + dbgMsg(">>>Dumping contents of '" + resolvedFile + "' " + "(" + protocol + ")"); while ((ln = fp.nextLine()) != null) { @@ -787,321 +1980,489 @@ public class JalviewLite extends Applet } } } - if ((al != null) && (al.getHeight() > 0)) - { - dbgMsg("Successfully loaded file."); - newAlignFrame = new AlignFrame(al, applet, file, embedded); - if (initialAlignFrame == null) - { - initialAlignFrame = newAlignFrame; - } - // update the focus. - currentAlignFrame = newAlignFrame; + return null; + } - if (protocol == jalview.io.AppletFormatAdapter.PASTE) - { - newAlignFrame.setTitle("Sequences from " + getDocumentBase()); - } + /** + * Load PDBFiles if any specified by parameter(s). Returns true if loaded, + * else false. + * + * @param alignFrame + * @return + */ + protected boolean loadPdbFiles(AlignFrame alignFrame) + { + boolean result = false; + /* + * Undocumented for 2.6 - + * related to JAL-434 + */ - newAlignFrame.statusBar.setText("Successfully loaded file " + file); + applet.setAlignPdbStructures(getDefaultParameter("alignpdbfiles", + false)); + /* + * + * + * + * + * + */ - String treeFile = applet.getParameter("tree"); - if (treeFile == null) + int pdbFileCount = 0; + // Accumulate pdbs here if they are heading for the same view (if + // alignPdbStructures is true) + Vector pdbs = new Vector(); + // create a lazy matcher if we're asked to + jalview.analysis.SequenceIdMatcher matcher = (applet + .getDefaultParameter("relaxedidmatch", false)) ? new jalview.analysis.SequenceIdMatcher( + alignFrame.getAlignViewport().getAlignment() + .getSequencesArray()) : null; + + String param; + do + { + if (pdbFileCount > 0) { - treeFile = applet.getParameter("treeFile"); + param = applet.getParameter("PDBFILE" + pdbFileCount); } - - if (treeFile != null) + else { - try - { - treeFile = setProtocolState(treeFile); - /* - * if (inArchive(treeFile)) { protocol = - * AppletFormatAdapter.CLASSLOADER; } else { protocol = - * AppletFormatAdapter.URL; treeFile = addProtocol(treeFile); } - */ - jalview.io.NewickFile fin = new jalview.io.NewickFile(treeFile, - protocol); - - fin.parse(); - - if (fin.getTree() != null) - { - newAlignFrame.loadTree(fin, treeFile); - dbgMsg("Successfuly imported tree."); - } - else - { - dbgMsg("Tree parameter did not resolve to a valid tree."); - } - } catch (Exception ex) - { - ex.printStackTrace(); - } + param = applet.getParameter("PDBFILE"); } - String param = getParameter("features"); if (param != null) { - param = setProtocolState(param); + PDBEntry pdb = new PDBEntry(); - newAlignFrame.parseFeaturesFile(param, protocol); - } - - param = getParameter("showFeatureSettings"); - if (param != null && param.equalsIgnoreCase("true")) - { - newAlignFrame.viewport.showSequenceFeatures(true); - new FeatureSettings(newAlignFrame.alignPanel); - } + String seqstring; + SequenceI[] seqs = null; + String[] chains = null; - param = getParameter("annotations"); - if (param != null) - { - param = setProtocolState(param); + StringTokenizer st = new StringTokenizer(param, " "); - if (new AnnotationFile().readAnnotationFile( - newAlignFrame.viewport.getAlignment(), param, protocol)) - { - newAlignFrame.alignPanel.fontChanged(); - newAlignFrame.alignPanel.setScrollValues(0, 0); - } - else + if (st.countTokens() < 2) { - System.err - .println("Annotations were not added from annotation file '" - + param + "'"); - } - - } + String sequence = applet.getParameter("PDBSEQ"); + if (sequence != null) + { + seqs = new SequenceI[] { matcher == null ? (Sequence) alignFrame + .getAlignViewport().getAlignment().findName(sequence) + : matcher.findIdMatch(sequence) }; + } - param = getParameter("jnetfile"); - if (param != null) - { - try - { - param = setProtocolState(param); - jalview.io.JPredFile predictions = new jalview.io.JPredFile( - param, protocol); - JnetAnnotationMaker.add_annotation(predictions, - newAlignFrame.viewport.getAlignment(), 0, false); // false==do - // not - // add - // sequence - // profile - // from - // concise - // output - newAlignFrame.alignPanel.fontChanged(); - newAlignFrame.alignPanel.setScrollValues(0, 0); - } catch (Exception ex) - { - ex.printStackTrace(); } - } - /* - * - * Undocumented for 2.6 - related to JAL-434 - */ - applet.setAlignPdbStructures(getDefaultParameter("alignpdbfiles",false)); - /* - * - * - * - * - * - */ - - int pdbFileCount = 0; - // Accumulate pdbs here if they are heading for the same view (if alignPdbStructures is true) - Vector pdbs=new Vector(); - do - { - if (pdbFileCount > 0) - param = getParameter("PDBFILE" + pdbFileCount); else - param = getParameter("PDBFILE"); - - if (param != null) { - PDBEntry pdb = new PDBEntry(); - - String seqstring; - SequenceI[] seqs = null; - String[] chains = null; + param = st.nextToken(); + Vector tmp = new Vector(); + Vector tmp2 = new Vector(); - StringTokenizer st = new StringTokenizer(param, " "); - - if (st.countTokens() < 2) - { - String sequence = applet.getParameter("PDBSEQ"); - if (sequence != null) - seqs = new SequenceI[] - { (Sequence) newAlignFrame.getAlignViewport() - .getAlignment().findName(sequence) }; - - } - else + while (st.hasMoreTokens()) { - param = st.nextToken(); - Vector tmp = new Vector(); - Vector tmp2 = new Vector(); - - while (st.hasMoreTokens()) - { - seqstring = st.nextToken(); - StringTokenizer st2 = new StringTokenizer(seqstring, "="); - if (st2.countTokens() > 1) - { - // This is the chain - tmp2.addElement(st2.nextToken()); - seqstring = st2.nextToken(); - } - tmp.addElement((Sequence) newAlignFrame.getAlignViewport() - .getAlignment().findName(seqstring)); - } - - seqs = new SequenceI[tmp.size()]; - tmp.copyInto(seqs); - if (tmp2.size() == tmp.size()) + seqstring = st.nextToken(); + StringTokenizer st2 = new StringTokenizer(seqstring, "="); + if (st2.countTokens() > 1) { - chains = new String[tmp2.size()]; - tmp2.copyInto(chains); + // This is the chain + tmp2.addElement(st2.nextToken()); + seqstring = st2.nextToken(); } + tmp.addElement(matcher == null ? (Sequence) alignFrame + .getAlignViewport().getAlignment() + .findName(seqstring) : matcher.findIdMatch(seqstring)); } - param = setProtocolState(param); - if (// !jmolAvailable - // && - protocol == AppletFormatAdapter.CLASSLOADER) + seqs = new SequenceI[tmp.size()]; + tmp.copyInto(seqs); + if (tmp2.size() == tmp.size()) { - // TODO: verify this Re: - // https://mantis.lifesci.dundee.ac.uk/view.php?id=36605 - // This exception preserves the current behaviour where, even if - // the local pdb file was identified in the class loader - protocol = AppletFormatAdapter.URL; // this is probably NOT - // CORRECT! - param = addProtocol(param); // + chains = new String[tmp2.size()]; + tmp2.copyInto(chains); } + } + param = setProtocolState(param); + + if (// !jmolAvailable + // && + protocol == AppletFormatAdapter.CLASSLOADER && !useXtrnalSviewer) + { + // Re: JAL-357 : the bug isn't a problem if we are using an + // external viewer! + // TODO: verify this Re: + // https://mantis.lifesci.dundee.ac.uk/view.php?id=36605 + // This exception preserves the current behaviour where, even if + // the local pdb file was identified in the class loader + protocol = AppletFormatAdapter.URL; // this is probably NOT + // CORRECT! + param = addProtocol(param); // + } - pdb.setFile(param); + pdb.setFile(param); - if (seqs != null) + if (seqs != null) + { + for (int i = 0; i < seqs.length; i++) { - for (int i = 0; i < seqs.length; i++) + if (seqs[i] != null) { - if (seqs[i] != null) - { - ((Sequence) seqs[i]).addPDBId(pdb); - } - else + ((Sequence) seqs[i]).addPDBId(pdb); + StructureSelectionManager.getStructureSelectionManager( + applet).registerPDBEntry(pdb); + } + else + { + if (JalviewLite.debug) { - if (JalviewLite.debug) - { - // this may not really be a problem but we give a warning - // anyway - System.err - .println("Warning: Possible input parsing error: Null sequence for attachment of PDB (sequence " - + i + ")"); - } + // this may not really be a problem but we give a warning + // anyway + System.err + .println("Warning: Possible input parsing error: Null sequence for attachment of PDB (sequence " + + i + ")"); } } - - if (!alignPdbStructures) { - newAlignFrame.newStructureView(applet, pdb, seqs, chains, + } + + if (!alignPdbStructures) + { + alignFrame.newStructureView(applet, pdb, seqs, chains, protocol); - } else { - pdbs.addElement(new Object[] { pdb, seqs, chains, new String(protocol)}); - } + } + else + { + pdbs.addElement(new Object[] { pdb, seqs, chains, + new String(protocol) }); } } + } + + pdbFileCount++; + } while (param != null || pdbFileCount < 10); + if (pdbs.size() > 0) + { + SequenceI[][] seqs = new SequenceI[pdbs.size()][]; + PDBEntry[] pdb = new PDBEntry[pdbs.size()]; + String[][] chains = new String[pdbs.size()][]; + String[] protocols = new String[pdbs.size()]; + for (int pdbsi = 0, pdbsiSize = pdbs.size(); pdbsi < pdbsiSize; pdbsi++) + { + Object[] o = (Object[]) pdbs.elementAt(pdbsi); + pdb[pdbsi] = (PDBEntry) o[0]; + seqs[pdbsi] = (SequenceI[]) o[1]; + chains[pdbsi] = (String[]) o[2]; + protocols[pdbsi] = (String) o[3]; + } + alignFrame.alignedStructureView(applet, pdb, seqs, chains, + protocols); + result = true; + } + return result; + } + + /** + * Load in a Jnetfile if specified by parameter. Returns true if loaded, + * else false. + * + * @param alignFrame + * @return + */ + protected boolean loadJnetFile(AlignFrame alignFrame) + { + boolean result = false; + String param = applet.getParameter("jnetfile"); + if (param != null) + { + try + { + param = setProtocolState(param); + JPredFile predictions = new JPredFile(param, protocol); + JnetAnnotationMaker.add_annotation(predictions, + alignFrame.viewport.getAlignment(), 0, false); + // false == do not add sequence profile from concise output + SequenceI repseq = alignFrame.viewport.getAlignment() + .getSequenceAt(0); + alignFrame.viewport.getAlignment().setSeqrep(repseq); + ColumnSelection cs = new ColumnSelection(); + cs.hideInsertionsFor(repseq); + alignFrame.viewport.setColumnSelection(cs); + alignFrame.alignPanel.fontChanged(); + alignFrame.alignPanel.setScrollValues(0, 0); + result = true; + } catch (Exception ex) + { + ex.printStackTrace(); + } + } + return result; + } + + /** + * Load annotations if specified by parameter. Returns true if loaded, else + * false. + * + * @param alignFrame + * @return + */ + protected boolean loadAnnotations(AlignFrame alignFrame) + { + boolean result = false; + String param = applet.getParameter("annotations"); + if (param != null) + { + param = setProtocolState(param); + + if (new AnnotationFile().annotateAlignmentView(alignFrame.viewport, + param, protocol)) + { + alignFrame.alignPanel.fontChanged(); + alignFrame.alignPanel.setScrollValues(0, 0); + result = true; + } + else + { + System.err + .println("Annotations were not added from annotation file '" + + param + "'"); + } + } + return result; + } + + /** + * Load features file and view settings as specified by parameters. Returns + * true if features were loaded, else false. + * + * @param alignFrame + * @return + */ + protected boolean loadFeatures(AlignFrame alignFrame) + { + boolean result = false; + // /////////////////////////// + // modify display of features + // we do this before any features have been loaded, ensuring any hidden + // groups are hidden when features first displayed + // + // hide specific groups + // + String param = applet.getParameter("hidefeaturegroups"); + if (param != null) + { + alignFrame.setFeatureGroupState(separatorListToArray(param), false); + // applet.setFeatureGroupStateOn(newAlignFrame, param, false); + } + // show specific groups + param = applet.getParameter("showfeaturegroups"); + if (param != null) + { + alignFrame.setFeatureGroupState(separatorListToArray(param), true); + // applet.setFeatureGroupStateOn(newAlignFrame, param, true); + } + // and now load features + param = applet.getParameter("features"); + if (param != null) + { + param = setProtocolState(param); + + result = alignFrame.parseFeaturesFile(param, protocol); + } + + param = applet.getParameter("showFeatureSettings"); + if (param != null && param.equalsIgnoreCase(TRUE)) + { + alignFrame.viewport.setShowSequenceFeatures(true); + new FeatureSettings(alignFrame.alignPanel); + } + return result; + } - pdbFileCount++; - } while (pdbFileCount < 10); - if (pdbs.size()>0) + /** + * Load a score file if specified by parameter. Returns true if file was + * loaded, else false. + * + * @param alignFrame + */ + protected boolean loadScoreFile(AlignFrame alignFrame) + { + boolean result = false; + String sScoreFile = applet.getParameter("scoreFile"); + if (sScoreFile != null && !"".equals(sScoreFile)) + { + try { - SequenceI[][] seqs = new SequenceI[pdbs.size()][]; - PDBEntry[] pdb = new PDBEntry[pdbs.size()]; - String[][] chains = new String[pdbs.size()][]; - String[] protocols = new String[pdbs.size()]; - for (int pdbsi=0,pdbsiSize=pdbs.size(); pdbsi cp) @@ -1152,7 +2533,11 @@ public class JalviewLite extends Applet } if (cp < list.length()) { - jv.addElement(list.substring(cp)); + String c = list.substring(cp); + if (!c.equals(separator)) + { + jv.addElement(c); + } } if (jv.size() > 0) { @@ -1189,20 +2574,32 @@ public class JalviewLite extends Applet */ public String arrayToSeparatorList(String[] list) { + return arrayToSeparatorList(list, separator); + } + + /** + * concatenate the list with separator + * + * @param list + * @param separator + * @return concatenated string + */ + public static String arrayToSeparatorList(String[] list, String separator) + { + // TODO use StringUtils version StringBuffer v = new StringBuffer(); - if (list != null && list.length>0) + if (list != null && list.length > 0) { - for (int i = 0, iSize = list.length - 1; i < iSize; i++) + for (int i = 0, iSize = list.length; i < iSize; i++) { if (list[i] != null) { + if (i > 0) + { + v.append(separator); + } v.append(list[i]); } - v.append(separator); - } - if (list[list.length - 1] != null) - { - v.append(list[list.length - 1]); } if (debug) { @@ -1217,12 +2614,13 @@ public class JalviewLite extends Applet System.err.println("Returning empty '" + separator + "' separated List\n"); } - return ""; + return "" + separator; } - /** - * @return - * @see jalview.appletgui.AlignFrame#getFeatureGroups() + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getFeatureGroups() */ public String getFeatureGroups() { @@ -1231,11 +2629,12 @@ public class JalviewLite extends Applet return lst; } - /** - * @param alf - * alignframe to get feature groups on - * @return - * @see jalview.appletgui.AlignFrame#getFeatureGroups() + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getFeatureGroupsOn(jalview.appletgui.AlignFrame + * ) */ public String getFeatureGroupsOn(AlignFrame alf) { @@ -1243,10 +2642,10 @@ public class JalviewLite extends Applet return lst; } - /** - * @param visible - * @return - * @see jalview.appletgui.AlignFrame#getFeatureGroupsOfState(boolean) + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getFeatureGroupsOfState(boolean) */ public String getFeatureGroupsOfState(boolean visible) { @@ -1254,58 +2653,77 @@ public class JalviewLite extends Applet .getFeatureGroupsOfState(visible)); } - /** - * @param alf - * align frame to get groups of state visible - * @param visible - * @return - * @see jalview.appletgui.AlignFrame#getFeatureGroupsOfState(boolean) + /* + * (non-Javadoc) + * + * @see + * jalview.bin.JalviewLiteJsApi#getFeatureGroupsOfStateOn(jalview.appletgui + * .AlignFrame, boolean) */ public String getFeatureGroupsOfStateOn(AlignFrame alf, boolean visible) { return arrayToSeparatorList(alf.getFeatureGroupsOfState(visible)); } - /** - * @param groups - * tab separated list of group names - * @param state - * true or false - * @see jalview.appletgui.AlignFrame#setFeatureGroupState(java.lang.String[], - * boolean) + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#setFeatureGroupStateOn(jalview.appletgui. + * AlignFrame, java.lang.String, boolean) */ - public void setFeatureGroupStateOn(AlignFrame alf, String groups, - boolean state) + public void setFeatureGroupStateOn(final AlignFrame alf, + final String groups, boolean state) { - boolean st = state;// !(state==null || state.equals("") || + final boolean st = state;// !(state==null || state.equals("") || // state.toLowerCase().equals("false")); - alf.setFeatureGroupState(separatorListToArray(groups), st); + java.awt.EventQueue.invokeLater(new Runnable() + { + @Override + public void run() + { + alf.setFeatureGroupState(separatorListToArray(groups), st); + } + }); } + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#setFeatureGroupState(java.lang.String, + * boolean) + */ public void setFeatureGroupState(String groups, boolean state) { setFeatureGroupStateOn(getDefaultTargetFrame(), groups, state); } - /** - * List separator string + /* + * (non-Javadoc) * - * @return the separator + * @see jalview.bin.JalviewLiteJsApi#getSeparator() */ public String getSeparator() { return separator; } - /** - * List separator string + /* + * (non-Javadoc) * - * @param separator - * the separator to set + * @see jalview.bin.JalviewLiteJsApi#setSeparator(java.lang.String) */ public void setSeparator(String separator) { + if (separator == null || separator.length() < 1) + { + // reset to default + separator = "" + ((char) 0x00AC); + } this.separator = separator; + if (debug) + { + System.err.println("Default Separator now: '" + separator + "'"); + } } /** @@ -1325,28 +2743,18 @@ public class JalviewLite extends Applet { return def; } - if (stn.toLowerCase().equals("true")) + if (TRUE.equalsIgnoreCase(stn)) { return true; } return false; } - /** - * bind a pdb file to a sequence in the given alignFrame. + /* + * (non-Javadoc) * - * @param alFrame - * - null or specific alignFrame. This specifies the dataset that - * will be searched for a seuqence called sequenceId - * @param sequenceId - * - sequenceId within the dataset. - * @param pdbEntryString - * - the short name for the PDB file - * @param pdbFile - * - pdb file - either a URL or a valid PDB file. - * @return true if binding was as success TODO: consider making an exception - * structure for indicating when PDB parsing or seqeunceId location - * fails. + * @see jalview.bin.JalviewLiteJsApi#addPdbFile(jalview.appletgui.AlignFrame, + * java.lang.String, java.lang.String, java.lang.String) */ public boolean addPdbFile(AlignFrame alFrame, String sequenceId, String pdbEntryString, String pdbFile) @@ -1364,51 +2772,236 @@ public class JalviewLite extends Applet return alignPdbStructures; } + public void start() + { + // callInitCallback(); + } + + private Hashtable jshashes = new Hashtable(); + + private Hashtable> jsmessages = new Hashtable>(); + + public void setJsMessageSet(String messageclass, String viewId, + String[] colcommands) + { + Hashtable msgset = jsmessages.get(messageclass); + if (msgset == null) + { + msgset = new Hashtable(); + jsmessages.put(messageclass, msgset); + } + msgset.put(viewId, colcommands); + long[] l = new long[colcommands.length]; + for (int i = 0; i < colcommands.length; i++) + { + l[i] = colcommands[i].hashCode(); + } + jshashes.put(messageclass + "|" + viewId, l); + } + + /* + * (non-Javadoc) + * + * @see jalview.bin.JalviewLiteJsApi#getJsMessage(java.lang.String, + * java.lang.String) + */ + public String getJsMessage(String messageclass, String viewId) + { + Hashtable msgset = jsmessages.get(messageclass); + if (msgset != null) + { + String[] msgs = msgset.get(viewId); + if (msgs != null) + { + for (int i = 0; i < msgs.length; i++) + { + if (msgs[i] != null) + { + String m = msgs[i]; + msgs[i] = null; + return m; + } + } + } + } + return ""; + } + + public boolean isJsMessageSetChanged(String string, String string2, + String[] colcommands) + { + long[] l = jshashes.get(string + "|" + string2); + if (l == null && colcommands != null) + { + return true; + } + for (int i = 0; i < colcommands.length; i++) + { + if (l[i] != colcommands[i].hashCode()) + { + return true; + } + } + return false; + } + + private Vector jsExecQueue = new Vector(); + + public Vector getJsExecQueue() + { + return jsExecQueue; + } + + public void setExecutor(JSFunctionExec jsFunctionExec2) + { + jsFunctionExec = jsFunctionExec2; + } + /** - * get all components associated with the applet of the given type - * @param class1 + * return the given colour value parameter or the given default if parameter + * not given + * + * @param colparam + * @param defcolour * @return */ - public Vector getAppletWindow(Class class1) + public Color getDefaultColourParameter(String colparam, Color defcolour) { - Vector wnds = new Vector(); - Component[] cmp = getComponents(); - if (cmp!=null) + String colprop = getParameter(colparam); + if (colprop == null || colprop.trim().length() == 0) { - for (int i=0;i 0) + String codebase = localref.toString(); + if (url.indexOf("/") == 0) { - return alFrame.addStructureViewInstance(viewer, - separatorListToArray(sequenceIds)); + String localfile = localref.getFile(); + url = codebase.substring(0, codebase.length() - localfile.length()) + + url; } else { - return alFrame.addStructureViewInstance(viewer, null); + url = localref + url; + } + if (debug) + { + System.err.println("URL: " + localref.toString()); + System.err.println("URL.getFile: " + localref.getFile()); + System.err.println("URL.getPath: " + localref.getPath()); + System.err.println("URL.getQuery: " + localref.getQuery()); + System.err.println("returning " + url); + } + return url; + } + + /** + * open a URL in the browser - resolving it according to relative refs and + * coping with javascript: protocol if necessary. + * + * @param url + * @param target + */ + public void showURL(String url, String target) + { + try + { + if (url.indexOf(":") == -1) + { + // TODO: verify (Bas Vroling bug) prepend codebase or server URL to + // form valid URL + // Should really use docbase, not codebase. + URL prepend; + url = resolveUrlForLocalOrAbsolute( + url, + prepend = getDefaultParameter("resolvetocodebase", false) ? getDocumentBase() + : getCodeBase()); + if (debug) + { + System.err + .println("Show url (prepended " + + prepend + + " - toggle resolvetocodebase if code/docbase resolution is wrong): " + + url); + } + } + else + { + if (debug) + { + System.err.println("Show url: " + url); + } + } + if (url.indexOf("javascript:") == 0) + { + // no target for the javascript context + getAppletContext().showDocument(new java.net.URL(url)); + } + else + { + getAppletContext().showDocument(new java.net.URL(url), target); + } + } catch (Exception ex) + { + ex.printStackTrace(); } - // return null; } + + /** + * bind structures in a viewer to any matching sequences in an alignFrame (use + * sequenceIds to limit scope of search to specific sequences) + * + * @param alFrame + * @param viewer + * @param sequenceIds + * @return TODO: consider making an exception structure for indicating when + * binding fails public SequenceStructureBinding + * addStructureViewInstance( AlignFrame alFrame, Object viewer, String + * sequenceIds) { + * + * if (sequenceIds != null && sequenceIds.length() > 0) { return + * alFrame.addStructureViewInstance(viewer, + * separatorListToArray(sequenceIds)); } else { return + * alFrame.addStructureViewInstance(viewer, null); } // return null; } */ }