X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2FJalviewLite.java;h=157c22bf6615bd9c42448f62b8af31eea26ff359;hb=153dd62dc91da13ae732600e6ea55ddbe15eab39;hp=331e7f53acd348d834572fd50ee2756dca94cd89;hpb=285388369aa586c03977a409a11d44b2ee17be16;p=jalview.git diff --git a/src/jalview/bin/JalviewLite.java b/src/jalview/bin/JalviewLite.java index 331e7f5..157c22b 100755 --- a/src/jalview/bin/JalviewLite.java +++ b/src/jalview/bin/JalviewLite.java @@ -1,329 +1,1414 @@ -/* -* Jalview - A Sequence Alignment Editor and Viewer -* Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle -* -* This program 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 2 -* of the License, or (at your option) any later version. -* -* This program 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 this program; if not, write to the Free Software -* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA -*/ -package jalview.bin; - -import jalview.appletgui.AlignFrame; - -import jalview.datamodel.*; - -import jalview.io.*; - -import java.applet.*; - -import java.awt.*; -import java.awt.event.*; -import jalview.appletgui.TreePanel; - - -/** - * Jalview Applet. Runs in Java 1.18 runtime - * - * @author $author$ - * @version $Revision$ - */ -public class JalviewLite extends Applet -{ - static int lastFrameX = 200; - static int lastFrameY = 200; - boolean fileFound = true; - String file = "No file"; - Button launcher = new Button("Start Jalview"); - - static AlignFrame currentAlignFrame; - boolean embedded = false; - - - /** - * init method for Jalview Applet - */ - public void init() - { - int r = 255; - int g = 255; - int b = 255; - String param = getParameter("RGB"); - - if (param != null) - { - try - { - r = Integer.parseInt(param.substring(0, 2), 16); - g = Integer.parseInt(param.substring(2, 4), 16); - b = Integer.parseInt(param.substring(4, 6), 16); - } - catch (Exception ex) - { - r = 255; - g = 255; - b = 255; - } - } - - param = getParameter("label"); - if(param != null) - launcher.setLabel(param); - - this.setBackground(new Color(r, g, b)); - - - param = getParameter("features"); - if(param!=null) - { - if(param.indexOf("://")==-1) - param = getCodeBase() + param; - } - final String featuresFile = param; - - file = getParameter("file"); - if(file.indexOf("://")==-1) - file = getCodeBase() + file; - - final JalviewLite applet = this; - if(getParameter("embedded")!=null - && getParameter("embedded").equalsIgnoreCase("true")) - { - embedded = true; - LoadingThread loader = new LoadingThread(file, - "URL", - featuresFile, - applet); - loader.start(); - } - else if (file != null) - { - add(launcher); - - launcher.addActionListener(new java.awt.event.ActionListener() - { - public void actionPerformed(ActionEvent e) - { - LoadingThread loader = new LoadingThread(file, - "URL", - featuresFile, - applet); - loader.start(); - } - }); - } - else - { - file = "NO FILE"; - fileFound = false; - } - } - - - public static void main(String [] args) - { - if(args.length!=1) - { - System.out.println("\nUsage: java -jar jalviewApplet.jar fileName\n"); - System.exit(1); - } - - String format = jalview.io.IdentifyFile.Identify(args[0],"File"); - SequenceI[] sequences = new AppletFormatAdapter().readFile(args[0], "File", format); - - if ( (sequences != null) && (sequences.length > 0)) - { - AlignFrame af = new AlignFrame(new Alignment(sequences), null, args[0]); - af.statusBar.setText("Successfully loaded file " + args[0]); - } - } - - - /** - * Initialises and displays a new java.awt.Frame - * - * @param frame java.awt.Frame to be displayed - * @param title title of new frame - * @param width width if new frame - * @param height height of new frame - */ - public static void addFrame(final Frame frame, String title, int width, - int height) - { - frame.setLocation(lastFrameX, lastFrameY); - lastFrameX += 40; - lastFrameY += 40; - frame.setSize(width, height); - frame.setTitle(title); - frame.addWindowListener(new WindowAdapter() - { - public void windowClosing(WindowEvent e) - { - if(currentAlignFrame == frame) - { - currentAlignFrame = null; - } - lastFrameX -=40; - lastFrameY-=40; - frame.setMenuBar(null); - frame.dispose(); - } - public void windowActivated(WindowEvent e) - { - if(frame instanceof AlignFrame) - currentAlignFrame = (AlignFrame)frame; - } - - }); - frame.setVisible(true); - } - - public String getAlignment(String format) - { - return getAlignment(format, "true"); - } - - public String getAlignment(String format, String suffix) - { - try - { - boolean seqlimits = suffix.equalsIgnoreCase("true"); - - String reply = new AppletFormatAdapter().formatSequences(format, - currentAlignFrame.viewport.getAlignment().getSequences(), seqlimits); - return reply; - } - catch (Exception ex) - { - ex.printStackTrace(); - return "Error retrieving alignment in " + format + " format. "; - } - } - - /** - * This paints the background surrounding the "Launch Jalview button" - *
- *
If file given in parameter not found, displays error message - * - * @param g graphics context - */ - public void paint(Graphics g) - { - if (!fileFound) - { - g.setColor(new Color(200, 200, 200)); - 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("\"" + file + "\"", 5, 30); - } - else if(embedded) - { - g.setColor(Color.black); - g.setFont(new Font("Arial", Font.BOLD, 24)); - g.drawString("Jalview Applet", 50, this.size().height/2 -30); - g.drawString("Loading Data...", 50, this.size().height/2); - } - - - } - - class LoadingThread extends Thread - { - String file; - String protocol; - String format; - String featuresFile; - JalviewLite applet; - - public LoadingThread(String file, - String protocol, - String features, - JalviewLite applet) - { - this.file = file; - this.protocol = protocol; - format = jalview.io.IdentifyFile.Identify(file, "URL"); - featuresFile = features; - this.applet = applet; - } - - public void run() - { - SequenceI[] sequences = null; - sequences = new AppletFormatAdapter().readFile(file, protocol, format); - - if ((sequences != null) && (sequences.length > 0)) - { - currentAlignFrame = new AlignFrame(new Alignment(sequences), - applet, file); - if (embedded) - currentAlignFrame.setEmbedded(); - - currentAlignFrame.statusBar.setText("Successfully loaded file " + file); - - if (featuresFile != null) - currentAlignFrame.parseFeaturesFile(featuresFile); - - String treeFile = applet.getParameter("treeFile"); - if (treeFile != null) - { - try - { - jalview.io.NewickFile fin = new jalview.io.NewickFile(applet. - getCodeBase() + treeFile, "URL"); - fin.parse(); - - if (fin.getTree() != null) - { - TreePanel tp = null; - tp = new TreePanel(currentAlignFrame.viewport, - currentAlignFrame.viewport.getAlignment().getSequences(), - fin, "FromFile", applet.getCodeBase() + treeFile); - addFrame(tp, treeFile, 600, 500); - currentAlignFrame.addTreeMenuItem(tp, treeFile); - } - } - catch (Exception ex) - { - ex.printStackTrace(); - } - } - - - String pdbfile = applet.getParameter("PDBFILE"); - if(pdbfile!=null) - { - if(pdbfile.indexOf("://")==-1) - pdbfile = getCodeBase() + pdbfile; - - String sequence = applet.getParameter("PDBSEQ"); - - if(sequence!=null) - { - new MCview.AppletPDBViewer(pdbfile, "URL", - (Sequence)currentAlignFrame.getAlignViewport().getAlignment().findName(sequence), - currentAlignFrame.getSeqcanvas()); - } - - } - } - else - { - fileFound = false; - remove(launcher); - repaint(); - } - } - } -} +/* + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6) + * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle + * + * 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. + * + * 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 . + */ +package jalview.bin; + +import jalview.api.SequenceStructureBinding; +import jalview.appletgui.AlignFrame; +import jalview.appletgui.AppletJmol; +import jalview.appletgui.EmbmenuFrame; +import jalview.appletgui.FeatureSettings; +import jalview.datamodel.Alignment; +import jalview.datamodel.PDBEntry; +import jalview.datamodel.Sequence; +import jalview.datamodel.SequenceI; +import jalview.io.AnnotationFile; +import jalview.io.AppletFormatAdapter; +import jalview.io.FileParse; +import jalview.io.IdentifyFile; +import jalview.io.JnetAnnotationMaker; + +import java.applet.Applet; +import java.awt.Button; +import java.awt.Color; +import java.awt.Component; +import java.awt.Font; +import java.awt.Frame; +import java.awt.Graphics; +import java.awt.event.ActionEvent; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.lang.reflect.Method; +import java.util.Enumeration; +import java.util.StringTokenizer; +import java.util.Vector; + +/** + * Jalview Applet. Runs in Java 1.18 runtime + * + * @author $author$ + * @version $Revision$ + */ +public class JalviewLite extends Applet +{ + + // ///////////////////////////////////////// + // The following public methods maybe called + // externally, eg via javascript in HTML page + /** + * @return String list of selected sequence IDs, each terminated by "¬" + * (¬) + */ + 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) + */ + public String getSelectedSequences(String sep) + { + return getSelectedSequencesFrom(getDefaultTargetFrame(), sep); + } + + /** + * @param alf + * alignframe containing selection + * @return String list of selected sequence IDs, each terminated by "¬" + * + */ + public String getSelectedSequencesFrom(AlignFrame alf) + { + return getSelectedSequencesFrom(alf, "¬"); + } + + /** + * get list of selected sequence IDs separated by given separator + * + * @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 + */ + public String getSelectedSequencesFrom(AlignFrame alf, String sep) + { + StringBuffer result = new StringBuffer(""); + if (sep == null || sep.length() == 0) + { + sep = "¬"; + } + if (alf.viewport.getSelectionGroup() != null) + { + SequenceI[] seqs = alf.viewport.getSelectionGroup() + .getSequencesInOrder(alf.viewport.getAlignment()); + + for (int i = 0; i < seqs.length; i++) + { + result.append(seqs[i].getName()); + result.append(sep); + } + } + + 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 + */ + public String getSelectedSequencesAsAlignment(String format, String suffix) + { + return getSelectedSequencesAsAlignmentFrom(currentAlignFrame, 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 + */ + public String getSelectedSequencesAsAlignmentFrom(AlignFrame alf, + String format, String suffix) + { + try + { + boolean seqlimits = suffix.equalsIgnoreCase("true"); + if (alf.viewport.getSelectionGroup() != null) + { + String reply = new AppletFormatAdapter().formatSequences(format, + new Alignment(alf.viewport.getSelectionAsNewSequence()), + seqlimits); + return reply; + } + } catch (Exception ex) + { + ex.printStackTrace(); + return "Error retrieving alignment in " + format + " format. "; + } + return ""; + } + + public String getAlignment(String format) + { + return getAlignmentFrom(getDefaultTargetFrame(), format, "true"); + } + + public String getAlignmentFrom(AlignFrame alf, String format) + { + return getAlignmentFrom(alf, format, "true"); + } + + public String getAlignment(String format, String suffix) + { + return getAlignmentFrom(getDefaultTargetFrame(), format, suffix); + } + + public String getAlignmentFrom(AlignFrame alf, String format, + String suffix) + { + try + { + boolean seqlimits = suffix.equalsIgnoreCase("true"); + + String reply = new AppletFormatAdapter().formatSequences(format, + alf.viewport.getAlignment(), seqlimits); + return reply; + } catch (Exception ex) + { + ex.printStackTrace(); + return "Error retrieving alignment in " + format + " format. "; + } + } + + public void loadAnnotation(String annotation) + { + loadAnnotationFrom(getDefaultTargetFrame(), annotation); + } + + public void loadAnnotationFrom(AlignFrame alf, String annotation) + { + if (new AnnotationFile().readAnnotationFile(alf.getAlignViewport() + .getAlignment(), annotation, AppletFormatAdapter.PASTE)) + { + alf.alignPanel.fontChanged(); + alf.alignPanel.setScrollValues(0, 0); + } + else + { + alf.parseFeaturesFile(annotation, AppletFormatAdapter.PASTE); + } + } + + public String getFeatures(String format) + { + return getFeaturesFrom(getDefaultTargetFrame(), format); + } + + public String getFeaturesFrom(AlignFrame alf, String format) + { + return alf.outputFeatures(false, format); + } + + public String getAnnotation() + { + return getAnnotationFrom(getDefaultTargetFrame()); + } + + public String getAnnotationFrom(AlignFrame alf) + { + return alf.outputAnnotations(false); + } + + public AlignFrame newView() + { + return newViewFrom(getDefaultTargetFrame()); + } + + public AlignFrame newView(String name) + { + return newViewFrom(getDefaultTargetFrame(), name); + } + + public AlignFrame newViewFrom(AlignFrame alf) + { + return alf.newView(null); + } + + public AlignFrame newViewFrom(AlignFrame alf, String name) + { + return alf.newView(name); + } + + /** + * + * @param text + * alignment file as a string + * @param title + * window title + * @return null or new alignment frame + */ + public AlignFrame loadAlignment(String text, String title) + { + Alignment al = null; + + String format = new IdentifyFile().Identify(text, + AppletFormatAdapter.PASTE); + try + { + al = new AppletFormatAdapter().readFile(text, + AppletFormatAdapter.PASTE, format); + if (al.getHeight() > 0) + { + return new AlignFrame(al, this, title, false); + } + } catch (java.io.IOException ex) + { + ex.printStackTrace(); + } + return null; + } + + // ////////////////////////////////////////////// + // ////////////////////////////////////////////// + + public static int lastFrameX = 200; + + public static int lastFrameY = 200; + + boolean fileFound = true; + + String file = "No file"; + + Button launcher = new Button("Start Jalview"); + + /** + * The currentAlignFrame is static, it will change if and when the user + * selects a new window. Note that it will *never* point back to the embedded + * AlignFrame if the applet is started as embedded on the page and then + * afterwards a new view is created. + */ + public static AlignFrame currentAlignFrame = null; + + /** + * This is the first frame to be displayed, and does not change. API calls + * will default to this instance if currentAlignFrame is null. + */ + AlignFrame initialAlignFrame = null; + + boolean embedded = false; + + private boolean checkForJmol = true; + + private boolean checkedForJmol = false; // ensure we don't check for jmol + + // every time the app is re-inited + + public boolean jmolAvailable = false; + + private boolean alignPdbStructures=false; + + public static boolean debug = false; + + static String builddate = null, version = null; + + private static void initBuildDetails() + { + if (builddate == null) + { + builddate = "unknown"; + version = "test"; + java.net.URL url = JalviewLite.class + .getResource("/.build_properties"); + if (url != null) + { + try + { + BufferedReader reader = new BufferedReader(new InputStreamReader( + url.openStream())); + String line; + while ((line = reader.readLine()) != null) + { + if (line.indexOf("VERSION") > -1) + { + version = line.substring(line.indexOf("=") + 1); + } + if (line.indexOf("BUILD_DATE") > -1) + { + builddate = line.substring(line.indexOf("=") + 1); + } + } + } catch (Exception ex) + { + ex.printStackTrace(); + } + } + } + } + + public static String getBuildDate() + { + initBuildDetails(); + return builddate; + } + + public static String getVersion() + { + initBuildDetails(); + return version; + } + + /** + * init method for Jalview Applet + */ + public void init() + { + + /** + * turn on extra applet debugging + */ + String dbg = getParameter("debug"); + if (dbg != null) + { + debug = dbg.toLowerCase().equals("true"); + } + if (debug) + { + + System.err.println("JalviewLite Version " + getVersion()); + System.err.println("Build Date : " + getBuildDate()); + + } + /** + * if true disable the check for jmol + */ + String chkforJmol = getParameter("nojmol"); + if (chkforJmol != null) + { + checkForJmol = !chkforJmol.equals("true"); + } + /** + * get the separator parameter if present + */ + String sep = getParameter("separator"); + if (sep != null) + { + if (sep.length() > 0) + { + separator = sep; + if (debug) + { + System.err.println("Separator set to '" + separator + "'"); + } + } + else + { + throw new Error( + "Invalid separator parameter - must be non-zero length"); + } + } + int r = 255; + int g = 255; + int b = 255; + String param = getParameter("RGB"); + + if (param != null) + { + try + { + r = Integer.parseInt(param.substring(0, 2), 16); + g = Integer.parseInt(param.substring(2, 4), 16); + b = Integer.parseInt(param.substring(4, 6), 16); + } catch (Exception ex) + { + r = 255; + g = 255; + b = 255; + } + } + + param = getParameter("label"); + if (param != null) + { + launcher.setLabel(param); + } + + this.setBackground(new Color(r, g, b)); + + file = getParameter("file"); + + if (file == null) + { + // 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(); + } + } + + final JalviewLite applet = this; + if (getParameter("embedded") != null + && getParameter("embedded").equalsIgnoreCase("true")) + { + // Launch as embedded applet in page + embedded = true; + LoadingThread loader = new LoadingThread(file, applet); + loader.start(); + } + else if (file != null) + { + if (getParameter("showbutton") == null + || !getParameter("showbutton").equalsIgnoreCase("false")) + { + // 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); + loader.start(); + } + }); + } + else + { + // Open jalviewLite immediately. + LoadingThread loader = new LoadingThread(file, applet); + loader.start(); + } + } + else + { + // jalview initialisation with no alignment. loadAlignment() method can + // still be called to open new alignments. + file = "NO FILE"; + fileFound = false; + } + } + + /** + * Initialises and displays a new java.awt.Frame + * + * @param frame + * java.awt.Frame to be displayed + * @param title + * title of new frame + * @param width + * width if new frame + * @param height + * height of new frame + */ + public static void addFrame(final Frame frame, String title, int width, + int height) + { + frame.setLocation(lastFrameX, lastFrameY); + lastFrameX += 40; + lastFrameY += 40; + frame.setSize(width, height); + frame.setTitle(title); + frame.addWindowListener(new WindowAdapter() + { + public void windowClosing(WindowEvent e) + { + if (frame instanceof AlignFrame) + { + ((AlignFrame) frame).closeMenuItem_actionPerformed(); + } + if (currentAlignFrame == frame) + { + currentAlignFrame = null; + } + lastFrameX -= 40; + lastFrameY -= 40; + if (frame instanceof EmbmenuFrame) + { + ((EmbmenuFrame) frame).destroyMenus(); + } + frame.setMenuBar(null); + frame.dispose(); + } + + public void windowActivated(WindowEvent e) + { + if (frame instanceof AlignFrame) + { + currentAlignFrame = (AlignFrame) frame; + if (debug) + { + System.err.println("Activated window " + frame); + } + } + // be good. + super.windowActivated(e); + } + /* + * Probably not necessary to do this - see TODO above. (non-Javadoc) + * + * @see + * java.awt.event.WindowAdapter#windowDeactivated(java.awt.event.WindowEvent + * ) + * + * public void windowDeactivated(WindowEvent e) { if (currentAlignFrame == + * frame) { currentAlignFrame = null; if (debug) { + * System.err.println("Deactivated window "+frame); } } + * super.windowDeactivated(e); } + */ + }); + frame.setVisible(true); + } + + /** + * This paints the background surrounding the "Launch Jalview button"
+ *
+ * If file given in parameter not found, displays error message + * + * @param g + * graphics context + */ + public void paint(Graphics g) + { + if (!fileFound) + { + g.setColor(new Color(200, 200, 200)); + 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("\"" + 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); + } + } + + class LoadJmolThread extends Thread + { + private boolean running = false; + + public void run() + { + if (running || checkedForJmol) + { + return; + } + running = true; + if (checkForJmol) + { + try + { + if (!System.getProperty("java.version").startsWith("1.1")) + { + Class.forName("org.jmol.adapter.smarter.SmarterJmolAdapter"); + jmolAvailable = true; + } + if (!jmolAvailable) + { + System.out + .println("Jmol not available - Using MCview for structures"); + } + } catch (java.lang.ClassNotFoundException ex) + { + } + } + else + { + jmolAvailable = false; + if (debug) + { + System.err + .println("Skipping Jmol check. Will use MCView (probably)"); + } + } + checkedForJmol = true; + running = false; + } + + public boolean notFinished() + { + return running || !checkedForJmol; + } + } + + 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; + + JalviewLite applet; + + private void dbgMsg(String msg) + { + if (applet.debug) + { + System.err.println(msg); + } + } + + /** + * update the protocol state variable for accessing the datasource located + * by file. + * + * @param file + * @return possibly updated datasource string + */ + public String setProtocolState(String file) + { + if (file.startsWith("PASTE")) + { + file = file.substring(5); + protocol = AppletFormatAdapter.PASTE; + } + else if (inArchive(file)) + { + protocol = AppletFormatAdapter.CLASSLOADER; + } + else + { + file = addProtocol(file); + protocol = AppletFormatAdapter.URL; + } + dbgMsg("Protocol identified as '" + protocol + "'"); + return file; + } + + public LoadingThread(String _file, JalviewLite _applet) + { + this._file = _file; + applet = _applet; + } + + public void run() + { + LoadJmolThread jmolchecker = new LoadJmolThread(); + jmolchecker.start(); + while (jmolchecker.notFinished()) + { + // wait around until the Jmol check is complete. + try + { + Thread.sleep(2); + } catch (Exception e) + { + } + ; + } + startLoading(); + } + + 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; + try + { + al = new AppletFormatAdapter().readFile(file, protocol, format); + } catch (java.io.IOException ex) + { + dbgMsg("File load exception."); + ex.printStackTrace(); + if (debug) + { + try + { + FileParse fp = new FileParse(file, protocol); + String ln = null; + dbgMsg(">>>Dumping contents of '" + file + "' " + "(" + + protocol + ")"); + while ((ln = fp.nextLine()) != null) + { + dbgMsg(ln); + } + dbgMsg(">>>Dump finished."); + } catch (Exception e) + { + System.err + .println("Exception when trying to dump the content of the file parameter."); + e.printStackTrace(); + } + } + } + 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; + + if (protocol == jalview.io.AppletFormatAdapter.PASTE) + { + newAlignFrame.setTitle("Sequences from " + getDocumentBase()); + } + + newAlignFrame.statusBar.setText("Successfully loaded file " + file); + + String treeFile = applet.getParameter("tree"); + if (treeFile == null) + { + treeFile = applet.getParameter("treeFile"); + } + + if (treeFile != null) + { + 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(); + } + } + + String param = getParameter("features"); + if (param != null) + { + param = setProtocolState(param); + + newAlignFrame.parseFeaturesFile(param, protocol); + } + + param = getParameter("showFeatureSettings"); + if (param != null && param.equalsIgnoreCase("true")) + { + newAlignFrame.viewport.showSequenceFeatures(true); + new FeatureSettings(newAlignFrame.alignPanel); + } + + param = getParameter("annotations"); + if (param != null) + { + param = setProtocolState(param); + + if (new AnnotationFile().readAnnotationFile( + newAlignFrame.viewport.getAlignment(), param, protocol)) + { + newAlignFrame.alignPanel.fontChanged(); + newAlignFrame.alignPanel.setScrollValues(0, 0); + } + else + { + System.err + .println("Annotations were not added from annotation file '" + + param + "'"); + } + + } + + 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; + + 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 + { + 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()) + { + chains = new String[tmp2.size()]; + tmp2.copyInto(chains); + } + } + param = setProtocolState(param); + + if (// !jmolAvailable + // && + protocol == AppletFormatAdapter.CLASSLOADER) + { + // 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); + + if (seqs != null) + { + for (int i = 0; i < seqs.length; i++) + { + if (seqs[i] != null) + { + ((Sequence) seqs[i]).addPDBId(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) { + newAlignFrame.newStructureView(applet, pdb, seqs, chains, + protocol); + } else { + pdbs.addElement(new Object[] { pdb, seqs, chains, new String(protocol)}); + } + } + } + + pdbFileCount++; + } while (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 cp) + { + jv.addElement(list.substring(cp, pos)); + cp = pos + seplen; + } + if (cp < list.length()) + { + jv.addElement(list.substring(cp)); + } + 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; + } + + /** + * concatenate the list with separator + * + * @param list + * @return concatenated string + */ + public String arrayToSeparatorList(String[] list) + { + StringBuffer v = new StringBuffer(); + if (list != null && list.length>0) + { + for (int i = 0, iSize = list.length - 1; i < iSize; i++) + { + if (list[i] != null) + { + v.append(list[i]); + } + v.append(separator); + } + if (list[list.length - 1] != null) + { + v.append(list[list.length - 1]); + } + 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 ""; + } + + /** + * @return + * @see jalview.appletgui.AlignFrame#getFeatureGroups() + */ + public String getFeatureGroups() + { + String lst = arrayToSeparatorList(getDefaultTargetFrame() + .getFeatureGroups()); + return lst; + } + + /** + * @param alf + * alignframe to get feature groups on + * @return + * @see jalview.appletgui.AlignFrame#getFeatureGroups() + */ + public String getFeatureGroupsOn(AlignFrame alf) + { + String lst = arrayToSeparatorList(alf.getFeatureGroups()); + return lst; + } + + /** + * @param visible + * @return + * @see jalview.appletgui.AlignFrame#getFeatureGroupsOfState(boolean) + */ + public String getFeatureGroupsOfState(boolean visible) + { + return arrayToSeparatorList(getDefaultTargetFrame() + .getFeatureGroupsOfState(visible)); + } + + /** + * @param alf + * align frame to get groups of state visible + * @param visible + * @return + * @see jalview.appletgui.AlignFrame#getFeatureGroupsOfState(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) + */ + public void setFeatureGroupStateOn(AlignFrame alf, String groups, + boolean state) + { + boolean st = state;// !(state==null || state.equals("") || + // state.toLowerCase().equals("false")); + alf.setFeatureGroupState(separatorListToArray(groups), st); + } + + public void setFeatureGroupState(String groups, boolean state) + { + setFeatureGroupStateOn(getDefaultTargetFrame(), groups, state); + } + + /** + * List separator string + * + * @return the separator + */ + public String getSeparator() + { + return separator; + } + + /** + * List separator string + * + * @param separator + * the separator to set + */ + public void setSeparator(String separator) + { + this.separator = separator; + } + + /** + * get boolean value of applet parameter 'name' and return default if + * parameter is not set + * + * @param name + * name of paremeter + * @param def + * the value to return otherwise + * @return true or false + */ + public boolean getDefaultParameter(String name, boolean def) + { + String stn; + if ((stn = getParameter(name)) == null) + { + return def; + } + if (stn.toLowerCase().equals("true")) + { + return true; + } + return false; + } + + /** + * bind a pdb file to a sequence in the given alignFrame. + * + * @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. + */ + public boolean addPdbFile(AlignFrame alFrame, String sequenceId, + String pdbEntryString, String pdbFile) + { + return alFrame.addPdbFile(sequenceId, pdbEntryString, pdbFile); + } + + protected void setAlignPdbStructures(boolean alignPdbStructures) + { + this.alignPdbStructures = alignPdbStructures; + } + + public boolean isAlignPdbStructures() + { + return alignPdbStructures; + } + + /** + * 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 0) + { + return alFrame.addStructureViewInstance(viewer, + separatorListToArray(sequenceIds)); + } + else + { + return alFrame.addStructureViewInstance(viewer, null); + } + // return null; + } + */ +}