package jalview.bin;
import jalview.analysis.AlignmentUtils;
-import jalview.api.AlignFrameI;
-import jalview.api.AlignViewportI;
-import jalview.api.JalviewApp;
import jalview.api.StructureSelectionManagerProvider;
import jalview.appletgui.AlignFrame;
import jalview.appletgui.AlignViewport;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AlignmentOrder;
import jalview.datamodel.ColumnSelection;
-import jalview.datamodel.HiddenColumns;
import jalview.datamodel.PDBEntry;
+import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.io.AnnotationFile;
import jalview.io.FileFormats;
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.javascript.MouseOverStructureListener;
-import jalview.renderer.seqfeatures.FeatureRenderer;
import jalview.structure.SelectionListener;
-import jalview.structure.SelectionSource;
import jalview.structure.StructureSelectionManager;
-import jalview.structure.VamsasSource;
import jalview.util.ColorUtils;
+import jalview.util.HttpUtils;
import jalview.util.MessageManager;
-import jalview.viewmodel.AlignmentViewport;
import java.applet.Applet;
import java.awt.Button;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
+import java.util.StringTokenizer;
import java.util.Vector;
import netscape.javascript.JSObject;
* @author $author$
* @version $Revision: 1.92 $
*/
-@SuppressWarnings("serial")
public class JalviewLite extends Applet
- implements StructureSelectionManagerProvider, JalviewLiteJsApi,
- JalviewApp
+ implements StructureSelectionManagerProvider, JalviewLiteJsApi
{
- public JalviewLite()
- {
- appLoader = new JalviewAppLoader(debug);
- }
private static final String TRUE = "true";
private static final String FALSE = "false";
return StructureSelectionManager.getStructureSelectionManager(this);
}
- @Override
- public StructureSelectionManagerProvider getStructureSelectionManagerProvider()
- {
- return this;
- }
-
// /////////////////////////////////////////
// The following public methods may be called
// externally, eg via javascript in HTML page
* .AlignFrame)
*/
@Override
- public String getSelectedSequencesFrom(AlignFrameI alf)
+ public String getSelectedSequencesFrom(AlignFrame alf)
{
return getSelectedSequencesFrom(alf, separator); // ""+0x00AC);
}
* .AlignFrame, java.lang.String)
*/
@Override
- public String getSelectedSequencesFrom(AlignFrameI alf, String sep)
+ public String getSelectedSequencesFrom(AlignFrame alf, String sep)
{
StringBuffer result = new StringBuffer("");
if (sep == null || sep.length() == 0)
{
sep = separator; // "+0x00AC;
}
- if (((AlignFrame) alf).viewport.getSelectionGroup() != null)
+ if (alf.viewport.getSelectionGroup() != null)
{
- SequenceI[] seqs = ((AlignFrame) alf).viewport.getSelectionGroup()
- .getSequencesInOrder(
- ((AlignFrame) alf).viewport.getAlignment());
+ SequenceI[] seqs = alf.viewport.getSelectionGroup()
+ .getSequencesInOrder(alf.viewport.getAlignment());
for (int i = 0; i < seqs.length; i++)
{
* java.lang.String, java.lang.String, java.lang.String)
*/
@Override
- public void highlightIn(final AlignFrameI alf, final String sequenceId,
+ 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(
- ((AlignFrame) alf).viewport.getAlignment().getSequencesArray());
+ alf.viewport.getAlignment().getSequencesArray());
final SequenceI sq = matcher.findIdMatch(sequenceId);
if (sq != null)
{
int apos = -1;
try
{
- apos = new Integer(position).intValue();
+ apos = Integer.valueOf(position).intValue();
apos--;
} catch (NumberFormatException ex)
{
* java.lang.String, java.lang.String)
*/
@Override
- public void selectIn(AlignFrameI alf, String sequenceIds, String columns)
+ public void selectIn(AlignFrame alf, String sequenceIds, String columns)
{
selectIn(alf, sequenceIds, columns, separator);
}
* java.lang.String, java.lang.String, java.lang.String)
*/
@Override
- public void selectIn(final AlignFrameI alf, String sequenceIds,
+ public void selectIn(final AlignFrame alf, String sequenceIds,
String columns, String sep)
{
if (sep == null || sep.length() == 0)
}
}
// deparse fields
- String[] ids = JalviewAppLoader.separatorListToArray(sequenceIds, sep);
- String[] cols = JalviewAppLoader.separatorListToArray(columns, sep);
+ String[] ids = separatorListToArray(sequenceIds, sep);
+ String[] cols = separatorListToArray(columns, sep);
final SequenceGroup sel = new SequenceGroup();
final ColumnSelection csel = new ColumnSelection();
- AlignmentI al = ((AlignFrame) alf).viewport.getAlignment();
+ AlignmentI al = alf.viewport.getAlignment();
jalview.analysis.SequenceIdMatcher matcher = new jalview.analysis.SequenceIdMatcher(
- ((AlignFrame) alf).viewport.getAlignment().getSequencesArray());
+ alf.viewport.getAlignment().getSequencesArray());
int start = 0, end = al.getWidth(), alw = al.getWidth();
boolean seqsfound = true;
if (ids != null && ids.length > 0)
int from = -1, to = -1;
try
{
- from = new Integer(cl.substring(0, p)).intValue();
+ from = Integer.valueOf(cl.substring(0, p)).intValue();
from--;
} catch (NumberFormatException ex)
{
}
try
{
- to = new Integer(cl.substring(p + 1)).intValue();
+ to = Integer.valueOf(cl.substring(p + 1)).intValue();
to--;
} catch (NumberFormatException ex)
{
int r = -1;
try
{
- r = new Integer(cl).intValue();
+ r = Integer.valueOf(cl).intValue();
r--;
} catch (NumberFormatException ex)
{
@Override
public void run()
{
- ((AlignFrame) alf).select(sel, csel, ((AlignFrame) alf)
- .getAlignViewport().getAlignment().getHiddenColumns());
+ alf.select(sel, csel,
+ alf.getAlignViewport().getAlignment().getHiddenColumns());
}
});
}
* .appletgui.AlignFrame, java.lang.String, java.lang.String)
*/
@Override
- public String getSelectedSequencesAsAlignmentFrom(AlignFrameI alf,
+ public String getSelectedSequencesAsAlignmentFrom(AlignFrame alf,
String format, String suffix)
{
try
{
FileFormatI theFormat = FileFormats.getInstance().forName(format);
boolean seqlimits = suffix.equalsIgnoreCase(TRUE);
- if (((AlignFrame) alf).viewport.getSelectionGroup() != null)
+ 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(theFormat,
- new Alignment(((AlignFrame) alf).viewport
- .getSelectionAsNewSequence()),
+ new Alignment(alf.viewport.getSelectionAsNewSequence()),
seqlimits);
return reply;
}
* )
*/
@Override
- public String getAlignmentOrderFrom(AlignFrameI alf)
+ public String getAlignmentOrderFrom(AlignFrame alf)
{
return getAlignmentOrderFrom(alf, separator);
}
* , java.lang.String)
*/
@Override
- public String getAlignmentOrderFrom(AlignFrameI alf, String sep)
+ public String getAlignmentOrderFrom(AlignFrame alf, String sep)
{
- AlignmentI alorder = ((AlignFrame) alf).getAlignViewport()
- .getAlignment();
+ AlignmentI alorder = alf.getAlignViewport().getAlignment();
String[] order = new String[alorder.getHeight()];
for (int i = 0; i < order.length; i++)
{
* java.lang.String, java.lang.String, java.lang.String)
*/
@Override
- public String orderAlignmentBy(AlignFrameI alf, String order,
+ public String orderAlignmentBy(AlignFrame alf, String order,
String undoName, String sep)
{
- String[] ids = JalviewAppLoader.separatorListToArray(order, sep);
+ String[] ids = separatorListToArray(order, sep);
SequenceI[] sqs = null;
if (ids != null && ids.length > 0)
{
jalview.analysis.SequenceIdMatcher matcher = new jalview.analysis.SequenceIdMatcher(
- ((AlignFrame) alf).viewport.getAlignment()
- .getSequencesArray());
+ alf.viewport.getAlignment().getSequencesArray());
int s = 0;
sqs = new SequenceI[ids.length];
for (int i = 0; i < ids.length; i++)
final String _undoName = undoName;
// TODO: deal with synchronization here: cannot raise any events until after
// this has returned.
- return ((AlignFrame) alf).sortBy(aorder, _undoName) ? TRUE : "";
+ return alf.sortBy(aorder, _undoName) ? TRUE : "";
}
/*
* java.lang.String)
*/
@Override
- public String getAlignmentFrom(AlignFrameI alf, String format)
+ public String getAlignmentFrom(AlignFrame alf, String format)
{
return getAlignmentFrom(alf, format, TRUE);
}
* java.lang.String, java.lang.String)
*/
@Override
- public String getAlignmentFrom(AlignFrameI alf, String format,
+ public String getAlignmentFrom(AlignFrame alf, String format,
String suffix)
{
try
FileFormatI theFormat = FileFormats.getInstance().forName(format);
String reply = new AppletFormatAdapter().formatSequences(theFormat,
- ((AlignFrame) alf).viewport.getAlignment(), seqlimits);
+ alf.viewport.getAlignment(), seqlimits);
return reply;
} catch (IllegalArgumentException ex)
{
* , java.lang.String)
*/
@Override
- public void loadAnnotationFrom(AlignFrameI alf, String annotation)
+ public void loadAnnotationFrom(AlignFrame alf, String annotation)
{
- if (new AnnotationFile().annotateAlignmentView(
- ((AlignFrame) alf).getAlignViewport(),
+ if (new AnnotationFile().annotateAlignmentView(alf.getAlignViewport(),
annotation, DataSourceType.PASTE))
{
- ((AlignFrame) alf).alignPanel.fontChanged();
- ((AlignFrame) alf).alignPanel.setScrollValues(0, 0);
+ alf.alignPanel.fontChanged();
+ alf.alignPanel.setScrollValues(0, 0);
}
else
{
- ((AlignFrame) alf).parseFeaturesFile(annotation,
- DataSourceType.PASTE);
+ alf.parseFeaturesFile(annotation, DataSourceType.PASTE);
}
}
* , java.lang.String)
*/
@Override
- public boolean loadFeaturesFrom(AlignFrameI alf, String features,
+ public boolean loadFeaturesFrom(AlignFrame alf, String features,
boolean autoenabledisplay)
{
- return ((AlignFrame) alf).parseFeaturesFile(features,
- DataSourceType.PASTE,
+ return alf.parseFeaturesFile(features, DataSourceType.PASTE,
autoenabledisplay);
}
* java.lang.String)
*/
@Override
- public String getFeaturesFrom(AlignFrameI alf, String format)
+ public String getFeaturesFrom(AlignFrame alf, String format)
{
- return ((AlignFrame) alf).outputFeatures(false, format);
+ return alf.outputFeatures(false, format);
}
/*
* )
*/
@Override
- public String getAnnotationFrom(AlignFrameI alf)
+ public String getAnnotationFrom(AlignFrame alf)
{
- return ((AlignFrame) alf).outputAnnotations(false);
+ return alf.outputAnnotations(false);
}
/*
* @see jalview.bin.JalviewLiteJsApi#newViewFrom(jalview.appletgui.AlignFrame)
*/
@Override
- public AlignFrame newViewFrom(AlignFrameI alf)
+ public AlignFrame newViewFrom(AlignFrame alf)
{
- return ((AlignFrame) alf).newView(null);
+ return alf.newView(null);
}
/*
* java.lang.String)
*/
@Override
- public AlignFrame newViewFrom(AlignFrameI alf, String name)
+ public AlignFrame newViewFrom(AlignFrame alf, String name)
{
- return ((AlignFrame) alf).newView(name);
+ return alf.newView(name);
}
/*
* , java.lang.String)
*/
@Override
- public void setMouseoverListener(AlignFrameI af, String listener)
+ public void setMouseoverListener(AlignFrame af, String listener)
{
if (listener != null)
{
}
}
jalview.javascript.MouseOverListener mol = new jalview.javascript.MouseOverListener(
- this, (AlignFrame) af, listener, debug);
+ this, af, listener);
javascriptListeners.addElement(mol);
StructureSelectionManager.getStructureSelectionManager(this)
.addStructureViewerListener(mol);
System.err.println("Added a mouseover listener for "
+ ((af == null) ? "All frames"
: "Just views for "
- + ((AlignFrame) af).getAlignViewport()
- .getSequenceSetId()));
+ + af.getAlignViewport().getSequenceSetId()));
System.err.println("There are now " + javascriptListeners.size()
+ " listeners in total.");
}
* , java.lang.String)
*/
@Override
- public void setSelectionListener(AlignFrameI af, String listener)
+ public void setSelectionListener(AlignFrame af, String listener)
{
if (listener != null)
{
}
}
jalview.javascript.JsSelectionSender mol = new jalview.javascript.JsSelectionSender(
- this, (AlignFrame) af, listener, debug);
+ this, af, listener);
javascriptListeners.addElement(mol);
StructureSelectionManager.getStructureSelectionManager(this)
.addSelectionListener(mol);
System.err.println("Added a selection listener for "
+ ((af == null) ? "All frames"
: "Just views for "
- + ((AlignFrame) af).getAlignViewport()
- .getSequenceSetId()));
+ + af.getAlignViewport().getSequenceSetId()));
System.err.println("There are now " + javascriptListeners.size()
+ " listeners in total.");
}
}
}
MouseOverStructureListener mol = new MouseOverStructureListener(this,
- listener, separatorListToArray(modelSet), debug);
+ listener, separatorListToArray(modelSet));
javascriptListeners.addElement(mol);
StructureSelectionManager.getStructureSelectionManager(this)
.addStructureViewerListener(mol);
* .AlignFrame, java.lang.String)
*/
@Override
- public void removeJavascriptListener(AlignFrameI af, String listener)
+ public void removeJavascriptListener(AlignFrame af, String listener)
{
if (listener != null)
{
}
if (jsFunctionExec != null)
{
- jsFunctionExec.tidyUp();
- jsFunctionExec = null;
+ jsFunctionExec.stopQueue();
+ jsFunctionExec.jvlite = null;
}
initialAlignFrame = null;
+ jsFunctionExec = null;
javascriptListeners = null;
StructureSelectionManager.release(this);
}
try
{
StructureSelectionManager.getStructureSelectionManager(me)
- .mouseOverStructure(new Integer(pdbResNum).intValue(),
+ .mouseOverStructure(Integer.valueOf(pdbResNum).intValue(),
chain, pdbfile);
if (debug)
{
* java.lang.String, java.lang.String)
*/
@Override
- public void scrollViewToIn(final AlignFrameI alf, final String topRow,
+ public void scrollViewToIn(final AlignFrame alf, final String topRow,
final String leftHandColumn)
{
java.awt.EventQueue.invokeLater(new Runnable()
{
try
{
- ((AlignFrame) alf).scrollTo(new Integer(topRow).intValue(),
- new Integer(leftHandColumn).intValue());
+ alf.scrollTo(Integer.valueOf(topRow).intValue(),
+ Integer.valueOf(leftHandColumn).intValue());
} catch (Exception ex)
{
* .AlignFrame, java.lang.String)
*/
@Override
- public void scrollViewToRowIn(final AlignFrameI alf, final String topRow)
+ public void scrollViewToRowIn(final AlignFrame alf, final String topRow)
{
java.awt.EventQueue.invokeLater(new Runnable()
{
try
{
- ((AlignFrame) alf).scrollToRow(new Integer(topRow).intValue());
+ alf.scrollToRow(Integer.valueOf(topRow).intValue());
} catch (Exception ex)
{
* .AlignFrame, java.lang.String)
*/
@Override
- public void scrollViewToColumnIn(final AlignFrameI alf,
+ public void scrollViewToColumnIn(final AlignFrame alf,
final String leftHandColumn)
{
java.awt.EventQueue.invokeLater(new Runnable()
{
try
{
- ((AlignFrame) alf)
- .scrollToColumn(new Integer(leftHandColumn).intValue());
+ alf.scrollToColumn(Integer.valueOf(leftHandColumn).intValue());
} catch (Exception ex)
{
boolean embedded = false;
- boolean checkForJmol = true;
+ private boolean checkForJmol = true;
- boolean checkedForJmol = false; // ensure we don't check for jmol
+ private boolean checkedForJmol = false; // ensure we don't check for jmol
// every time the app is re-inited
*/
public boolean useXtrnalSviewer = false;
- public JalviewAppLoader appLoader;
-
- public AlignFrame loaderFrame;
-
public static boolean debug = false;
static String builddate = null, version = null, installation = null;
.getString("error.invalid_separator_parameter"));
}
}
-
- // Background color
-
int r = 255;
int g = 255;
int b = 255;
b = 255;
}
}
- setBackground(new Color(r, g, b));
-
param = getParameter("label");
if (param != null)
{
launcher.setLabel(param);
}
+ setBackground(new Color(r, g, b));
+
file = getParameter("file");
if (file == null)
{
- file = appLoader.getPastedSequence(this);
+ // Maybe the sequences are added as parameters
+ StringBuffer data = new StringBuffer("PASTE");
+ int i = 1;
+ while ((file = getParameter("sequence" + i)) != null)
+ {
+ data.append(file.toString() + "\n");
+ i++;
+ }
+ if (data.length() > 5)
+ {
+ file = data.toString();
+ }
}
if (getDefaultParameter("enableSplitFrame", true))
{
file2 = getParameter("file2");
}
- embedded = (TRUE.equalsIgnoreCase(getParameter("embedded"))
- || file != null
- && FALSE.equalsIgnoreCase(getParameter("showbutton")));
+ embedded = TRUE.equalsIgnoreCase(getParameter("embedded"));
if (embedded)
{
- startLoading();
+ LoadingThread loader = new LoadingThread(file, file2, this);
+ loader.start();
+ }
+ else if (file != null)
+ {
+ /*
+ * 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(launcher);
+ launcher.addActionListener(new java.awt.event.ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ LoadingThread loader = new LoadingThread(file, file2,
+ JalviewLite.this);
+ loader.start();
+ }
+ });
+ }
}
- else if (file == null)
+ else
{
// jalview initialisation with no alignment. loadAlignment() method can
// still be called to open new alignments.
fileFound = false;
callInitCallback();
}
- else
- {
- add(launcher);
- launcher.addActionListener(new java.awt.event.ActionListener()
- {
- @Override
- public void actionPerformed(ActionEvent e)
- {
- startLoading();
- }
- });
- }
- }
-
- protected void startLoading()
- {
- LoadingThread loader = new LoadingThread(file, file2, this);
- loader.start();
}
private void initLiveConnect()
}
}
- void callInitCallback()
+ private void callInitCallback()
{
String initjscallback = getParameter("oninit");
if (initjscallback == null)
try
{
// do onInit with the JS executor thread
- new JSFunctionExec(this, debug).executeJavascriptFunction(true,
+ new JSFunctionExec(this).executeJavascriptFunction(true,
initjscallback, null,
"Calling oninit callback '" + initjscallback + "'.");
} catch (Exception e)
JalviewLite applet;
- public void dbgMsg(String msg)
+ private void dbgMsg(String msg)
{
if (JalviewLite.debug)
{
*/
public String resolveFileProtocol(String path)
{
+ /*
+ * is it paste data?
+ */
+ if (path.startsWith("PASTE"))
+ {
+ protocol = DataSourceType.PASTE;
+ return path.substring(5);
+ }
- String[] ret = new String[] { path };
- protocol = JalviewAppLoader.resolveFileProtocol(applet, ret);
- return ret[0];
+ /*
+ * is it a URL?
+ */
+ if (path.indexOf("://") != -1)
+ {
+ protocol = DataSourceType.URL;
+ return path;
+ }
+
+ /*
+ * try relative to document root
+ */
+ URL documentBase = getDocumentBase();
+ String withDocBase = resolveUrlForLocalOrAbsolute(path, documentBase);
+ if (HttpUtils.isValidUrl(withDocBase))
+ {
+ if (debug)
+ {
+ System.err.println("Prepended document base '" + documentBase
+ + "' to make: '" + withDocBase + "'");
+ }
+ protocol = DataSourceType.URL;
+ return withDocBase;
+ }
+
+ /*
+ * try relative to codebase (if different to document base)
+ */
+ URL codeBase = getCodeBase();
+ String withCodeBase = applet.resolveUrlForLocalOrAbsolute(path,
+ codeBase);
+ if (!withCodeBase.equals(withDocBase)
+ && HttpUtils.isValidUrl(withCodeBase))
+ {
+ protocol = DataSourceType.URL;
+ if (debug)
+ {
+ System.err.println("Prepended codebase '" + codeBase
+ + "' to make: '" + withCodeBase + "'");
+ }
+ return withCodeBase;
+ }
+
+ /*
+ * try locating by classloader; try this last so files in the directory
+ * are resolved using document base
+ */
+ if (inArchive(path))
+ {
+ protocol = DataSourceType.CLASSLOADER;
+ }
+ return path;
}
public LoadingThread(String file, String file2, JalviewLite _applet)
if (newAlignFrame != null)
{
addToDisplay(newAlignFrame, newAlignFrame2);
- applet.loaderFrame = newAlignFrame;
- appLoader.load(applet);
+ loadTree(newAlignFrame);
+
+ loadScoreFile(newAlignFrame);
+
+ loadFeatures(newAlignFrame);
+
+ loadAnnotations(newAlignFrame);
+
+ loadJnetFile(newAlignFrame);
+
+ loadPdbFiles(newAlignFrame);
}
else
{
fileFound = false;
applet.remove(launcher);
applet.repaint();
- callInitCallback();
}
+ callInitCallback();
}
/**
return null;
}
+ /**
+ * 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;
+ /*
+ * <param name="alignpdbfiles" value="false/true"/> Undocumented for 2.6 -
+ * related to JAL-434
+ */
+
+ applet.setAlignPdbStructures(
+ getDefaultParameter("alignpdbfiles", false));
+ /*
+ * <param name="PDBfile" value="1gaq.txt PDB|1GAQ|1GAQ|A PDB|1GAQ|1GAQ|B
+ * PDB|1GAQ|1GAQ|C">
+ *
+ * <param name="PDBfile2" value="1gaq.txt A=SEQA B=SEQB C=SEQB">
+ *
+ * <param name="PDBfile3" value="1q0o Q45135_9MICO">
+ */
+
+ 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)
+ {
+ param = applet.getParameter("PDBFILE" + pdbFileCount);
+ }
+ else
+ {
+ param = applet.getParameter("PDBFILE");
+ }
+
+ if (param != null)
+ {
+ PDBEntry pdb = new PDBEntry();
+
+ String seqstring;
+ SequenceI[] seqs = null;
+ String[] chains = null;
+
+ StringTokenizer st = new StringTokenizer(param, " ");
+
+ if (st.countTokens() < 2)
+ {
+ String sequence = applet.getParameter("PDBSEQ");
+ if (sequence != null)
+ {
+ seqs = new SequenceI[] { matcher == null
+ ? (Sequence) alignFrame.getAlignViewport()
+ .getAlignment().findName(sequence)
+ : matcher.findIdMatch(sequence) };
+ }
+
+ }
+ else
+ {
+ param = st.nextToken();
+ List<SequenceI> tmp = new ArrayList<>();
+ List<String> tmp2 = new ArrayList<>();
+
+ while (st.hasMoreTokens())
+ {
+ seqstring = st.nextToken();
+ StringTokenizer st2 = new StringTokenizer(seqstring, "=");
+ if (st2.countTokens() > 1)
+ {
+ // This is the chain
+ tmp2.add(st2.nextToken());
+ seqstring = st2.nextToken();
+ }
+ tmp.add(matcher == null
+ ? (Sequence) alignFrame.getAlignViewport()
+ .getAlignment().findName(seqstring)
+ : matcher.findIdMatch(seqstring));
+ }
+
+ seqs = tmp.toArray(new SequenceI[tmp.size()]);
+ if (tmp2.size() == tmp.size())
+ {
+ chains = tmp2.toArray(new String[tmp2.size()]);
+ }
+ }
+ param = resolveFileProtocol(param);
+ // TODO check JAL-357 for files in a jar (CLASSLOADER)
+ pdb.setFile(param);
+
+ if (seqs != null)
+ {
+ for (int i = 0; i < seqs.length; i++)
+ {
+ if (seqs[i] != null)
+ {
+ ((Sequence) seqs[i]).addPDBId(pdb);
+ StructureSelectionManager
+ .getStructureSelectionManager(applet)
+ .registerPDBEntry(pdb);
+ }
+ else
+ {
+ 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 + ")");
+ }
+ }
+ }
+
+ if (!alignPdbStructures)
+ {
+ alignFrame.newStructureView(applet, pdb, seqs, chains,
+ protocol);
+ }
+ else
+ {
+ pdbs.addElement(new Object[] { pdb, seqs, chains, 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)
+ {
+ // jnet became jpred around 2016
+ param = applet.getParameter("jpredfile");
+ }
+ if (param != null)
+ {
+ try
+ {
+ param = resolveFileProtocol(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
+
+ alignFrame.viewport.getAlignment().setupJPredAlignment();
+
+ 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 = resolveFileProtocol(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 = resolveFileProtocol(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;
+ }
+
+ /**
+ * 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
+ {
+ if (debug)
+ {
+ System.err.println(
+ "Attempting to load T-COFFEE score file from the scoreFile parameter");
+ }
+ result = alignFrame.loadScoreFile(sScoreFile);
+ if (!result)
+ {
+ System.err.println(
+ "Failed to parse T-COFFEE parameter as a valid score file ('"
+ + sScoreFile + "')");
+ }
+ } catch (Exception e)
+ {
+ System.err.printf("Cannot read score file: '%s'. Cause: %s \n",
+ sScoreFile, e.getMessage());
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Load a tree for the alignment if specified by parameter. Returns true if
+ * a tree was loaded, else false.
+ *
+ * @param alignFrame
+ * @return
+ */
+ protected boolean loadTree(AlignFrame alignFrame)
+ {
+ boolean result = false;
+ String treeFile = applet.getParameter("tree");
+ if (treeFile == null)
+ {
+ treeFile = applet.getParameter("treeFile");
+ }
+
+ if (treeFile != null)
+ {
+ try
+ {
+ treeFile = resolveFileProtocol(treeFile);
+ NewickFile fin = new NewickFile(treeFile, protocol);
+ fin.parse();
+
+ if (fin.getTree() != null)
+ {
+ alignFrame.loadTree(fin, treeFile);
+ result = true;
+ dbgMsg("Successfully imported tree.");
+ }
+ else
+ {
+ dbgMsg("Tree parameter did not resolve to a valid tree.");
+ }
+ } catch (Exception ex)
+ {
+ ex.printStackTrace();
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Discovers whether the given file is in the Applet Archive
+ *
+ * @param f
+ * String
+ * @return boolean
+ */
+ boolean inArchive(String f)
+ {
+ // This might throw a security exception in certain browsers
+ // Netscape Communicator for instance.
+ try
+ {
+ boolean rtn = (getClass().getResourceAsStream("/" + f) != null);
+ if (debug)
+ {
+ System.err.println("Resource '" + f + "' was "
+ + (rtn ? "" : "not ") + "located by classloader.");
+ }
+ return rtn;
+ } catch (Exception ex)
+ {
+ System.out.println("Exception checking resources: " + f + " " + ex);
+ return false;
+ }
+ }
}
/**
/**
* set to enable the URL based javascript execution mechanism
*/
- private boolean jsfallbackEnabled = false;
+ public boolean jsfallbackEnabled = false;
/**
* parse the string into a list
* @param list
* @return elements separated by separator
*/
- @Override
public String[] separatorListToArray(String list)
{
- return JalviewAppLoader.separatorListToArray(list, separator);
+ return separatorListToArray(list, separator);
+ }
+
+ /**
+ * parse the string into a list
+ *
+ * @param list
+ * @param separator
+ * @return elements separated by separator
+ */
+ public static String[] separatorListToArray(String list, String separator)
+ {
+ // TODO use StringUtils version (slightly different...)
+ int seplen = separator.length();
+ if (list == null || list.equals("") || list.equals(separator))
+ {
+ return null;
+ }
+ java.util.Vector jv = new Vector();
+ int cp = 0, pos;
+ while ((pos = list.indexOf(separator, cp)) > cp)
+ {
+ jv.addElement(list.substring(cp, pos));
+ cp = pos + seplen;
+ }
+ if (cp < list.length())
+ {
+ String c = list.substring(cp);
+ if (!c.equals(separator))
+ {
+ jv.addElement(c);
+ }
+ }
+ if (jv.size() > 0)
+ {
+ String[] v = new String[jv.size()];
+ for (int i = 0; i < v.length; i++)
+ {
+ v[i] = (String) jv.elementAt(i);
+ }
+ jv.removeAllElements();
+ if (debug)
+ {
+ System.err.println("Array from '" + separator
+ + "' separated List:\n" + v.length);
+ for (int i = 0; i < v.length; i++)
+ {
+ System.err.println("item " + i + " '" + v[i] + "'");
+ }
+ }
+ return v;
+ }
+ if (debug)
+ {
+ System.err.println(
+ "Empty Array from '" + separator + "' separated List");
+ }
+ return null;
}
/**
* @param list
* @return concatenated string
*/
- @Override
public String arrayToSeparatorList(String[] list)
{
- return JalviewAppLoader.arrayToSeparatorList(list, separator);
+ 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)
+ {
+ for (int i = 0, iSize = list.length; i < iSize; i++)
+ {
+ if (list[i] != null)
+ {
+ if (i > 0)
+ {
+ v.append(separator);
+ }
+ v.append(list[i]);
+ }
+ }
+ if (debug)
+ {
+ System.err
+ .println("Returning '" + separator + "' separated List:\n");
+ System.err.println(v);
+ }
+ return v.toString();
+ }
+ if (debug)
+ {
+ System.err.println(
+ "Returning empty '" + separator + "' separated List\n");
+ }
+ return "" + separator;
}
/*
* )
*/
@Override
- public String getFeatureGroupsOn(AlignFrameI alf)
+ public String getFeatureGroupsOn(AlignFrame alf)
{
- String lst = arrayToSeparatorList(
- ((AlignFrame) alf).getFeatureGroups());
+ String lst = arrayToSeparatorList(alf.getFeatureGroups());
return lst;
}
* .AlignFrame, boolean)
*/
@Override
- public String getFeatureGroupsOfStateOn(AlignFrameI alf, boolean visible)
+ public String getFeatureGroupsOfStateOn(AlignFrame alf, boolean visible)
{
- return arrayToSeparatorList(
- ((AlignFrame) alf).getFeatureGroupsOfState(visible));
+ return arrayToSeparatorList(alf.getFeatureGroupsOfState(visible));
}
/*
* AlignFrame, java.lang.String, boolean)
*/
@Override
- public void setFeatureGroupStateOn(final AlignFrameI alf,
+ public void setFeatureGroupStateOn(final AlignFrame alf,
final String groups, boolean state)
{
final boolean st = state;// !(state==null || state.equals("") ||
@Override
public void run()
{
- ((AlignFrame) alf)
- .setFeatureGroupState(separatorListToArray(groups), st);
+ alf.setFeatureGroupState(separatorListToArray(groups), st);
}
});
}
* the value to return otherwise
* @return true or false
*/
- @Override
public boolean getDefaultParameter(String name, boolean def)
{
String stn;
* java.lang.String, java.lang.String, java.lang.String)
*/
@Override
- public boolean addPdbFile(AlignFrameI alFrame, String sequenceId,
+ public boolean addPdbFile(AlignFrame alFrame, String sequenceId,
String pdbEntryString, String pdbFile)
{
- return ((AlignFrame) alFrame).addPdbFile(sequenceId, pdbEntryString,
- pdbFile);
+ return alFrame.addPdbFile(sequenceId, pdbEntryString, pdbFile);
}
- @Override
- public void setAlignPdbStructures(boolean alignPdbStructures)
+ protected void setAlignPdbStructures(boolean alignPdbStructures)
{
this.alignPdbStructures = alignPdbStructures;
}
// callInitCallback();
}
- private Hashtable<String, int[]> jshashes = new Hashtable<>();
+ private Hashtable<String, long[]> jshashes = new Hashtable<>();
private Hashtable<String, Hashtable<String, String[]>> jsmessages = new Hashtable<>();
+ public void setJsMessageSet(String messageclass, String viewId,
+ String[] colcommands)
+ {
+ Hashtable<String, String[]> 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)
+ */
@Override
- public Hashtable<String, int[]> getJSHashes()
+ public String getJsMessage(String messageclass, String viewId)
{
- return jshashes;
+ Hashtable<String, String[]> 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 "";
}
- @Override
- public Hashtable<String, Hashtable<String, String[]>> getJSMessages()
+ public boolean isJsMessageSetChanged(String string, String string2,
+ String[] colcommands)
{
- return jsmessages;
+ 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<Runnable> jsExecQueue = new Vector<>();
+ private Vector jsExecQueue = new Vector();
- @Override
- public Vector<Runnable> getJsExecQueue(JSFunctionExec exec)
+ public Vector getJsExecQueue()
{
- jsFunctionExec = exec;
return jsExecQueue;
}
- // public void setExecutor(JSFunctionExec jsFunctionExec2)
- // {
- // jsFunctionExec = jsFunctionExec2;
- // }
+ public void setExecutor(JSFunctionExec jsFunctionExec2)
+ {
+ jsFunctionExec = jsFunctionExec2;
+ }
/**
* return the given colour value parameter or the given default if parameter
}
/**
+ * form a complete URL given a path to a resource and a reference location on
+ * the same server
+ *
+ * @param targetPath
+ * - an absolute path on the same server as localref or a document
+ * located relative to localref
+ * @param localref
+ * - a URL on the same server as url
+ * @return a complete URL for the resource located by url
+ */
+ private String resolveUrlForLocalOrAbsolute(String targetPath,
+ URL localref)
+ {
+ String resolvedPath = "";
+ if (targetPath.startsWith("/"))
+ {
+ String codebase = localref.toString();
+ String localfile = localref.getFile();
+ resolvedPath = codebase.substring(0,
+ codebase.length() - localfile.length()) + targetPath;
+ return resolvedPath;
+ }
+
+ /*
+ * get URL path and strip off any trailing file e.g.
+ * www.jalview.org/examples/index.html#applets?a=b is trimmed to
+ * www.jalview.org/examples/
+ */
+ String urlPath = localref.toString();
+ String directoryPath = urlPath;
+ int lastSeparator = directoryPath.lastIndexOf("/");
+ if (lastSeparator > 0)
+ {
+ directoryPath = directoryPath.substring(0, lastSeparator + 1);
+ }
+
+ if (targetPath.startsWith("/"))
+ {
+ /*
+ * construct absolute URL to a file on the server - this is not allowed?
+ */
+ // String localfile = localref.getFile();
+ // resolvedPath = urlPath.substring(0,
+ // urlPath.length() - localfile.length())
+ // + targetPath;
+ resolvedPath = directoryPath + targetPath.substring(1);
+ }
+ else
+ {
+ resolvedPath = directoryPath + targetPath;
+ }
+ if (debug)
+ {
+ System.err.println(
+ "resolveUrlForLocalOrAbsolute returning " + resolvedPath);
+ }
+ return resolvedPath;
+ }
+
+ /**
* open a URL in the browser - resolving it according to relative refs and
* coping with javascript: protocol if necessary.
*
// form valid URL
// Should really use docbase, not codebase.
URL prepend;
- url = JalviewAppLoader.resolveUrlForLocalOrAbsolute(url,
+ url = resolveUrlForLocalOrAbsolute(url,
prepend = getDefaultParameter("resolvetocodebase", false)
? getCodeBase()
: getDocumentBase());
}
}
- @Override
- public AlignViewportI getViewport()
- {
- return loaderFrame.getAlignViewport();
- }
-
- @Override
- public void newStructureView(PDBEntry pdb, SequenceI[] seqs,
- String[] chains, DataSourceType protocol)
- {
- loaderFrame.newStructureView(this, pdb, seqs, chains,
- protocol);
- }
-
- @Override
- public void alignedStructureView(PDBEntry[] pdb, SequenceI[][] seqs,
- String[][] chains, String[] protocols)
- {
- loaderFrame.alignedStructureView(this, pdb, seqs, chains, protocols);
- }
-
- @Override
- public void updateForAnnotations()
- {
- loaderFrame.alignPanel.fontChanged();
- loaderFrame.alignPanel.setScrollValues(0, 0);
- }
-
- @Override
- public void setFeatureGroupState(String[] groups, boolean state)
- {
- loaderFrame.setFeatureGroupState(groups, state);
- }
-
- @Override
- public boolean parseFeaturesFile(String param, DataSourceType protocol)
- {
- return loaderFrame.parseFeaturesFile(param, protocol);
- }
-
- @Override
- public void newFeatureSettings()
- {
- getViewport().setShowSequenceFeatures(true);
- new FeatureSettings(loaderFrame.alignPanel);
- }
-
- @Override
- public boolean loadScoreFile(String sScoreFile) throws IOException
- {
- return loaderFrame.loadScoreFile(sScoreFile);
- }
-
- @Override
- public void loadTree(NewickFile tree, String treeFile) throws IOException
- {
- loaderFrame.loadTree(tree, treeFile);
- }
-
- @Override
- public boolean isJsfallbackEnabled()
- {
- return jsfallbackEnabled;
- }
-
- @Override
- public JSObject getJSObject()
- {
- return JSObject.getWindow(this);
- }
-
- @Override
- public void updateColoursFromMouseOver(Object source,
- MouseOverStructureListener listener)
- {
- }
-
- @Override
- public Object[] getSelectionForListener(SequenceGroup seqsel, ColumnSelection colsel,
- HiddenColumns hidden, SelectionSource source, Object alignFrame)
- {
- // System.err.println("Testing selection event relay to
- // jsfunction:"+_listener);
- String setid = "";
- AlignFrame src = (AlignFrame) alignFrame;
- if (source != null)
- {
- if (source instanceof jalview.appletgui.AlignViewport
- && ((jalview.appletgui.AlignViewport) source).applet.currentAlignFrame.viewport == source)
- {
- // should be valid if it just generated an event!
- src = ((jalview.appletgui.AlignViewport) source).applet.currentAlignFrame;
-
- }
- }
- String[] seqs = new String[] {};
- String[] cols = new String[] {};
- int strt = 0, end = (src == null) ? -1
- : src.alignPanel.av.getAlignment().getWidth();
- if (seqsel != null && seqsel.getSize() > 0)
- {
- seqs = new String[seqsel.getSize()];
- for (int i = 0; i < seqs.length; i++)
- {
- seqs[i] = seqsel.getSequenceAt(i).getName();
- }
- if (strt < seqsel.getStartRes())
- {
- strt = seqsel.getStartRes();
- }
- if (end == -1 || end > seqsel.getEndRes())
- {
- end = seqsel.getEndRes();
- }
- }
- if (colsel != null && !colsel.isEmpty())
- {
- if (end == -1)
- {
- end = colsel.getMax() + 1;
- }
- cols = new String[colsel.getSelected().size()];
- for (int i = 0; i < cols.length; i++)
- {
- cols[i] = "" + (1 + colsel.getSelected().get(i).intValue());
- }
- }
- else
- {
- if (seqsel != null && seqsel.getSize() > 0)
- {
- // send a valid range, otherwise we send the empty selection
- cols = new String[2];
- cols[0] = "" + (1 + strt) + "-" + (1 + end);
- }
- }
- return new Object[]
- { src, setid, arrayToSeparatorList(seqs), arrayToSeparatorList(cols) };
- }
-
- @Override
- public String getJsMessage(String messageclass, String viewId)
- {
- return JSFunctionExec.getJsMessage(messageclass, viewId, this);
- }
-
- @Override
- public Object getFrameForSource(VamsasSource source)
- {
- if (source != null)
- {
- if (source instanceof jalview.appletgui.AlignViewport
- && ((jalview.appletgui.AlignViewport) source).applet.currentAlignFrame.viewport == source)
- {
- // should be valid if it just generated an event!
- return ((jalview.appletgui.AlignViewport) source).applet.currentAlignFrame;
-
- }
- // TODO: ensure that if '_af' is specified along with a handler
- // function, then only events from that alignFrame are sent to that
- // function
- }
- return null;
- }
-
- @Override
- public FeatureRenderer getNewFeatureRenderer(AlignViewportI vp)
- {
- return new jalview.appletgui.FeatureRenderer((AlignmentViewport) vp);
- }
-
- @Override
- public String getSelectedSequencesAsAlignment(String format,
- boolean suffix)
- {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public String getSelectedSequencesAsAlignmentFrom(AlignFrameI alf,
- String format, boolean suffix)
- {
- // TODO Auto-generated method stub
- 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; }
- // */
+ /**
+ * 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; }
+ */
}
git://source.jalview.org / jalview.git / blobdiff