From: janengelhardt Date: Mon, 13 Jun 2011 23:06:32 +0000 (+0200) Subject: Container for VARNA classes are created according to Jmol classes. X-Git-Tag: Jalview_2_9~576^2~37 X-Git-Url: http://source.jalview.org/gitweb/?a=commitdiff_plain;h=722f0bee96b96ceeb8ef69b3ccd1aeff13786b2b;p=jalview.git Container for VARNA classes are created according to Jmol classes. Must be filled with VARNA specific content now!, see JAL-842 Change-Id: I526d70ab7bbb3aef81bfbe130ca2cc295a82e4e8 --- diff --git a/src/jalview/datamodel/Annotation.java b/src/jalview/datamodel/Annotation.java index 762a62c..b0464dd 100755 --- a/src/jalview/datamodel/Annotation.java +++ b/src/jalview/datamodel/Annotation.java @@ -34,7 +34,7 @@ public class Annotation public String description = ""; // currently used as mouse over /** DOCUMENT ME!! */ - public char secondaryStructure = ' '; // recognises H and E + public char secondaryStructure = ' '; // recognises H, E and S(?) /** DOCUMENT ME!! */ public float value; diff --git a/src/jalview/ext/varna/JalviewVarnaBinding.java b/src/jalview/ext/varna/JalviewVarnaBinding.java new file mode 100644 index 0000000..65a2665 --- /dev/null +++ b/src/jalview/ext/varna/JalviewVarnaBinding.java @@ -0,0 +1,1546 @@ +/* + * 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.ext.varna; + +import java.io.File; +import java.net.URL; +import java.util.*; +import java.applet.Applet; +import java.awt.*; +import java.awt.event.*; + +import javax.swing.JPanel; + +import jalview.api.AlignmentViewPanel; +import jalview.api.FeatureRenderer; +import jalview.api.SequenceRenderer; +import jalview.api.SequenceStructureBinding; +import jalview.api.StructureSelectionManagerProvider; +import jalview.datamodel.*; +import jalview.structure.*; +import jalview.io.*; + +import org.jmol.api.*; +import org.jmol.adapter.smarter.SmarterJmolAdapter; + +import org.jmol.popup.*; +import org.jmol.viewer.JmolConstants; +import org.jmol.viewer.Viewer; + +import jalview.schemes.*; + +public abstract class JalviewVarnaBinding implements StructureListener, + JmolStatusListener, SequenceStructureBinding, + JmolSelectionListener, ComponentListener, StructureSelectionManagerProvider + +{ + /** + * set if Jmol state is being restored from some source - instructs binding + * not to apply default display style when structure set is updated for first + * time. + */ + private boolean loadingFromArchive = false; + + /** + * state flag used to check if the Jmol viewer's paint method can be called + */ + private boolean finishedInit = false; + + public boolean isFinishedInit() + { + return finishedInit; + } + + public void setFinishedInit(boolean finishedInit) + { + this.finishedInit = finishedInit; + } + + boolean allChainsSelected = false; + + /** + * when true, try to search the associated datamodel for sequences that are + * associated with any unknown structures in the Jmol view. + */ + private boolean associateNewStructs = false; + + Vector atomsPicked = new Vector(); + + public Vector chainNames; + + Hashtable chainFile; + + /** + * array of target chains for seuqences - tied to pdbentry and sequence[] + */ + protected String[][] chains; + + boolean colourBySequence = true; + + StringBuffer eval = new StringBuffer(); + + public String fileLoadingError; + + /** + * the default or current model displayed if the model cannot be identified + * from the selection message + */ + int frameNo = 0; + + protected JmolPopup jmolpopup; + + String lastCommand; + + String lastMessage; + + boolean loadedInline; + + /** + * current set of model filenames loaded in the Jmol instance + */ + String[] modelFileNames = null; + + public PDBEntry[] pdbentry; + + /** + * datasource protocol for access to PDBEntrylatest + */ + String protocol = null; + + StringBuffer resetLastRes = new StringBuffer(); + + /** + * sequences mapped to each pdbentry + */ + public SequenceI[][] sequence; + + public StructureSelectionManager ssm; + + public JmolViewer viewer; + + public JalviewVarnaBinding(StructureSelectionManager ssm, PDBEntry[] pdbentry, SequenceI[][] sequenceIs, + String[][] chains, String protocol) + { + this.ssm = ssm; + this.sequence = sequenceIs; + this.chains = chains; + this.pdbentry = pdbentry; + this.protocol = protocol; + if (chains == null) + { + this.chains = new String[pdbentry.length][]; + } + /* + * viewer = JmolViewer.allocateViewer(renderPanel, new SmarterJmolAdapter(), + * "jalviewJmol", ap.av.applet .getDocumentBase(), + * ap.av.applet.getCodeBase(), "", this); + * + * jmolpopup = JmolPopup.newJmolPopup(viewer, true, "Jmol", true); + */ + } + + public JalviewVarnaBinding(StructureSelectionManager ssm, JmolViewer viewer2) + { + this.ssm = ssm; + viewer = viewer2; + viewer.setJmolStatusListener(this); + viewer.addSelectionListener(this); + } + + /** + * construct a title string for the viewer window based on the data jalview + * knows about + * + * @return + */ + public String getViewerTitle() + { + if (sequence == null || pdbentry == null || sequence.length < 1 + || pdbentry.length < 1 || sequence[0].length < 1) + { + return ("Jalview Jmol Window"); + } + // TODO: give a more informative title when multiple structures are + // displayed. + StringBuffer title = new StringBuffer(sequence[0][0].getName() + ":" + + pdbentry[0].getId()); + + if (pdbentry[0].getProperty() != null) + { + if (pdbentry[0].getProperty().get("method") != null) + { + title.append(" Method: "); + title.append(pdbentry[0].getProperty().get("method")); + } + if (pdbentry[0].getProperty().get("chains") != null) + { + title.append(" Chain:"); + title.append(pdbentry[0].getProperty().get("chains")); + } + } + return title.toString(); + } + + /** + * prepare the view for a given set of models/chains. chainList contains + * strings of the form 'pdbfilename:Chaincode' + * + * @param chainList + * list of chains to make visible + */ + public void centerViewer(Vector chainList) + { + StringBuffer cmd = new StringBuffer(); + String lbl; + int mlength, p; + for (int i = 0, iSize = chainList.size(); i < iSize; i++) + { + mlength = 0; + lbl = (String) chainList.elementAt(i); + do + { + p = mlength; + mlength = lbl.indexOf(":", p); + } while (p < mlength && mlength < (lbl.length() - 2)); + // TODO: lookup each pdb id and recover proper model number for it. + cmd.append(":" + lbl.substring(mlength + 1) + " /" + + (1 + getModelNum((String) chainFile.get(lbl))) + " or "); + } + if (cmd.length() > 0) + cmd.setLength(cmd.length() - 4); + evalStateCommand("select *;restrict " + cmd + ";cartoon;center " + cmd); + } + + public void closeViewer() + { + viewer.setModeMouse(org.jmol.viewer.JmolConstants.MOUSE_NONE); + // remove listeners for all structures in viewer + ssm.removeStructureViewerListener(this, this.getPdbFile()); + // and shut down jmol + viewer.evalStringQuiet("zap"); + viewer.setJmolStatusListener(null); + lastCommand = null; + viewer = null; + releaseUIResources(); + } + + /** + * called by JalviewJmolbinding after closeViewer is called - release any + * resources and references so they can be garbage collected. + */ + protected abstract void releaseUIResources(); + + public void colourByChain() + { + colourBySequence = false; + // TODO: colour by chain should colour each chain distinctly across all + // visible models + // TODO: http://issues.jalview.org/browse/JAL-628 + evalStateCommand("select *;color chain"); + } + + public void colourByCharge() + { + colourBySequence = false; + evalStateCommand("select *;color white;select ASP,GLU;color red;" + + "select LYS,ARG;color blue;select CYS;color yellow"); + } + + /** + * superpose the structures associated with sequences in the alignment + * according to their corresponding positions. + */ + public void superposeStructures(AlignmentI alignment) + { + superposeStructures(alignment, -1, null); + } + + /** + * superpose the structures associated with sequences in the alignment + * according to their corresponding positions. ded) + * + * @param refStructure + * - select which pdb file to use as reference (default is -1 - the + * first structure in the alignment) + */ + public void superposeStructures(AlignmentI alignment, int refStructure) + { + superposeStructures(alignment, refStructure, null); + } + + /** + * superpose the structures associated with sequences in the alignment + * according to their corresponding positions. ded) + * + * @param refStructure + * - select which pdb file to use as reference (default is -1 - the + * first structure in the alignment) + * @param hiddenCols + * TODO + */ + public void superposeStructures(AlignmentI alignment, int refStructure, + ColumnSelection hiddenCols) + { + superposeStructures(new AlignmentI[] + { alignment }, new int[] + { refStructure }, new ColumnSelection[] + { hiddenCols }); + } + + public void superposeStructures(AlignmentI[] _alignment, + int[] _refStructure, ColumnSelection[] _hiddenCols) + { + String[] files = getPdbFile(); + StringBuffer selectioncom = new StringBuffer(); + assert (_alignment.length == _refStructure.length && _alignment.length != _hiddenCols.length); + // union of all aligned positions are collected together. + for (int a = 0; a < _alignment.length; a++) + { + int refStructure = _refStructure[a]; + AlignmentI alignment = _alignment[a]; + ColumnSelection hiddenCols = _hiddenCols[a]; + if (a > 0 + && selectioncom.length() > 0 + && !selectioncom.substring(selectioncom.length() - 1).equals( + "|")) + { + selectioncom.append("|"); + } + // process this alignment + if (refStructure >= files.length) + { + System.err.println("Invalid reference structure value " + + refStructure); + refStructure = -1; + } + if (refStructure < -1) + { + refStructure = -1; + } + StringBuffer command = new StringBuffer(); + + boolean matched[] = new boolean[alignment.getWidth()]; + for (int m = 0; m < matched.length; m++) + { + + matched[m] = (hiddenCols != null) ? hiddenCols.isVisible(m) : true; + } + + int commonrpositions[][] = new int[files.length][alignment.getWidth()]; + String isel[] = new String[files.length]; + // reference structure - all others are superposed in it + String[] targetC = new String[files.length]; + String[] chainNames = new String[files.length]; + for (int pdbfnum = 0; pdbfnum < files.length; pdbfnum++) + { + StructureMapping[] mapping = ssm.getMapping(files[pdbfnum]); + + if (mapping == null || mapping.length < 1) + continue; + + int lastPos = -1; + for (int s = 0; s < sequence[pdbfnum].length; s++) + { + for (int sp, m = 0; m < mapping.length; m++) + { + if (mapping[m].getSequence() == sequence[pdbfnum][s] + && (sp = alignment.findIndex(sequence[pdbfnum][s])) > -1) + { + if (refStructure == -1) + { + refStructure = pdbfnum; + } + SequenceI asp = alignment.getSequenceAt(sp); + for (int r = 0; r < matched.length; r++) + { + if (!matched[r]) + { + continue; + } + matched[r] = false; // assume this is not a good site + if (r >= asp.getLength()) + { + continue; + } + + if (jalview.util.Comparison.isGap(asp.getCharAt(r))) + { + // no mapping to gaps in sequence + continue; + } + int t = asp.findPosition(r); // sequence position + int apos = mapping[m].getAtomNum(t); + int pos = mapping[m].getPDBResNum(t); + + if (pos < 1 || pos == lastPos) + { + // can't align unmapped sequence + continue; + } + matched[r] = true; // this is a good ite + lastPos = pos; + // just record this residue position + commonrpositions[pdbfnum][r] = pos; + } + // create model selection suffix + isel[pdbfnum] = "/" + (pdbfnum + 1) + ".1"; + if (mapping[m].getChain() == null + || mapping[m].getChain().trim().length() == 0) + { + targetC[pdbfnum] = ""; + } + else + { + targetC[pdbfnum] = ":" + mapping[m].getChain(); + } + chainNames[pdbfnum] = mapping[m].getPdbId() + + targetC[pdbfnum]; + // move on to next pdb file + s = sequence[pdbfnum].length; + break; + } + } + } + } + String[] selcom = new String[files.length]; + int nmatched = 0; + // generate select statements to select regions to superimpose structures + { + for (int pdbfnum = 0; pdbfnum < files.length; pdbfnum++) + { + String chainCd = targetC[pdbfnum]; + int lpos = -1; + boolean run = false; + StringBuffer molsel = new StringBuffer(); + molsel.append("{"); + for (int r = 0; r < matched.length; r++) + { + if (matched[r]) + { + if (pdbfnum == 0) + { + nmatched++; + } + if (lpos != commonrpositions[pdbfnum][r] - 1) + { + // discontinuity + if (lpos != -1) + { + molsel.append(lpos); + molsel.append(chainCd); + // molsel.append("} {"); + molsel.append("|"); + } + } + else + { + // continuous run - and lpos >-1 + if (!run) + { + // at the beginning, so add dash + molsel.append(lpos); + molsel.append("-"); + } + run = true; + } + lpos = commonrpositions[pdbfnum][r]; + // molsel.append(lpos); + } + } + // add final selection phrase + if (lpos != -1) + { + molsel.append(lpos); + molsel.append(chainCd); + molsel.append("}"); + } + selcom[pdbfnum] = molsel.toString(); + selectioncom.append("(("); + selectioncom.append(selcom[pdbfnum].substring(1, + selcom[pdbfnum].length() - 1)); + selectioncom.append(" )& "); + selectioncom.append(pdbfnum + 1); + selectioncom.append(".1)"); + if (pdbfnum < files.length - 1) + { + selectioncom.append("|"); + } + } + } + // TODO: consider bailing if nmatched less than 4 because superposition + // not + // well defined. + // TODO: refactor superposable position search (above) from jmol selection + // construction (below) + for (int pdbfnum = 0; pdbfnum < files.length; pdbfnum++) + { + if (pdbfnum == refStructure) + { + continue; + } + command.append("echo "); + command.append("\"Superposing ("); + command.append(chainNames[pdbfnum]); + command.append(") against reference ("); + command.append(chainNames[refStructure]); + command.append(")\";\ncompare "); + command.append("{"); + command.append(1 + pdbfnum); + command.append(".1} {"); + command.append(1 + refStructure); + command.append(".1} SUBSET {*.CA | *.P} ATOMS "); + + // form the matched pair strings + String sep = ""; + for (int s = 0; s < 2; s++) + { + command.append(selcom[(s == 0 ? pdbfnum : refStructure)]); + } + command.append(" ROTATE TRANSLATE;\n"); + } + System.out.println("Select regions:\n" + selectioncom.toString()); + evalStateCommand("select *; cartoons off; backbone; select (" + + selectioncom.toString() + "); cartoons; "); + // selcom.append("; ribbons; "); + System.out.println("Superimpose command(s):\n" + command.toString()); + + evalStateCommand(command.toString()); + } + if (selectioncom.length() > 0) + {// finally, mark all regions that were superposed. + if (selectioncom.substring(selectioncom.length() - 1).equals("|")) + { + selectioncom.setLength(selectioncom.length() - 1); + } + System.out.println("Select regions:\n" + selectioncom.toString()); + evalStateCommand("select *; cartoons off; backbone; select (" + + selectioncom.toString() + "); cartoons; "); + // evalStateCommand("select *; backbone; select "+selcom.toString()+"; cartoons; center "+selcom.toString()); + } + } + + public void evalStateCommand(String command) + { + jmolHistory(false); + if (lastCommand == null || !lastCommand.equals(command)) + { + viewer.evalStringQuiet(command + "\n"); + } + jmolHistory(true); + lastCommand = command; + } + + /** + * colour any structures associated with sequences in the given alignment + * using the getFeatureRenderer() and getSequenceRenderer() renderers but only + * if colourBySequence is enabled. + */ + public void colourBySequence(boolean showFeatures, + jalview.api.AlignmentViewPanel alignmentv) + { + if (!colourBySequence) + return; + if (ssm == null) + { + return; + } + String[] files = getPdbFile(); + + SequenceRenderer sr = getSequenceRenderer(alignmentv); + + FeatureRenderer fr = null; + if (showFeatures) + { + fr = getFeatureRenderer(alignmentv); + } + AlignmentI alignment = alignmentv.getAlignment(); + + for (String cbyseq : VarnaCommands.getColourBySequenceCommand(ssm, files, sequence, sr, fr, alignment)) { + evalStateCommand(cbyseq); + } + } + + public boolean isColourBySequence() + { + return colourBySequence; + } + + public void setColourBySequence(boolean colourBySequence) + { + this.colourBySequence = colourBySequence; + } + + public void createImage(String file, String type, int quality) + { + System.out.println("JMOL CREATE IMAGE"); + } + + public String createImage(String fileName, String type, + Object textOrBytes, int quality) + { + System.out.println("JMOL CREATE IMAGE"); + return null; + } + + public String eval(String strEval) + { + // System.out.println(strEval); + // "# 'eval' is implemented only for the applet."; + return null; + } + + // End StructureListener + // ////////////////////////// + + public float[][] functionXY(String functionName, int x, int y) + { + return null; + } + + public float[][][] functionXYZ(String functionName, int nx, int ny, int nz) + { + // TODO Auto-generated method stub + return null; + } + + public Color getColour(int atomIndex, int pdbResNum, String chain, + String pdbfile) + { + if (getModelNum(pdbfile) < 0) + return null; + // TODO: verify atomIndex is selecting correct model. + return new Color(viewer.getAtomArgb(atomIndex)); + } + + /** + * returns the current featureRenderer that should be used to colour the + * structures + * + * @param alignment + * + * @return + */ + public abstract FeatureRenderer getFeatureRenderer( + AlignmentViewPanel alignment); + + /** + * instruct the Jalview binding to update the pdbentries vector if necessary + * prior to matching the jmol view's contents to the list of structure files + * Jalview knows about. + */ + public abstract void refreshPdbEntries(); + + private int getModelNum(String modelFileName) + { + String[] mfn = getPdbFile(); + if (mfn == null) + { + return -1; + } + for (int i = 0; i < mfn.length; i++) + { + if (mfn[i].equalsIgnoreCase(modelFileName)) + return i; + } + return -1; + } + + /** + * map between index of model filename returned from getPdbFile and the first + * index of models from this file in the viewer. Note - this is not trimmed - + * use getPdbFile to get number of unique models. + */ + private int _modelFileNameMap[]; + + // //////////////////////////////// + // /StructureListener + public synchronized String[] getPdbFile() + { + if (viewer == null) + { + return new String[0]; + } + if (modelFileNames == null) + { + + String mset[] = new String[viewer.getModelCount()]; + _modelFileNameMap = new int[mset.length]; + int j = 1; + mset[0] = viewer.getModelFileName(0); + for (int i = 1; i < mset.length; i++) + { + mset[j] = viewer.getModelFileName(i); + _modelFileNameMap[j] = i; // record the model index for the filename + // skip any additional models in the same file (NMR structures) + if ((mset[j] == null ? mset[j] != mset[j - 1] + : (mset[j - 1] == null || !mset[j].equals(mset[j - 1])))) + { + j++; + } + } + modelFileNames = new String[j]; + System.arraycopy(mset, 0, modelFileNames, 0, j); + } + return modelFileNames; + } + + /** + * map from string to applet + */ + public Map getRegistryInfo() + { + // TODO Auto-generated method stub + return null; + } + + /** + * returns the current sequenceRenderer that should be used to colour the + * structures + * + * @param alignment + * + * @return + */ + public abstract SequenceRenderer getSequenceRenderer( + AlignmentViewPanel alignment); + + // /////////////////////////////// + // JmolStatusListener + + public void handlePopupMenu(int x, int y) + { + jmolpopup.show(x, y); + } + + // jmol/ssm only + public void highlightAtom(int atomIndex, int pdbResNum, String chain, + String pdbfile) + { + if (modelFileNames == null) + { + return; + } + + // look up file model number for this pdbfile + int mdlNum = 0; + String fn; + // may need to adjust for URLencoding here - we don't worry about that yet. + while (mdlNum < modelFileNames.length + && !pdbfile.equals(modelFileNames[mdlNum])) + { + // System.out.println("nomatch:"+pdbfile+"\nmodelfn:"+fn); + mdlNum++; + } + if (mdlNum == modelFileNames.length) + { + return; + } + + jmolHistory(false); + // if (!pdbfile.equals(pdbentry.getFile())) + // return; + if (resetLastRes.length() > 0) + { + viewer.evalStringQuiet(resetLastRes.toString()); + } + + eval.setLength(0); + eval.append("select " + pdbResNum); // +modelNum + + resetLastRes.setLength(0); + resetLastRes.append("select " + pdbResNum); // +modelNum + + eval.append(":"); + resetLastRes.append(":"); + if (!chain.equals(" ")) + { + eval.append(chain); + resetLastRes.append(chain); + } + { + eval.append(" /" + (mdlNum + 1)); + resetLastRes.append("/" + (mdlNum + 1)); + } + eval.append(";wireframe 100;" + eval.toString() + " and not hetero;"); + + resetLastRes.append(";wireframe 0;" + resetLastRes.toString() + + " and not hetero; spacefill 0;"); + + eval.append("spacefill 200;select none"); + + viewer.evalStringQuiet(eval.toString()); + jmolHistory(true); + + } + + boolean debug = true; + + private void jmolHistory(boolean enable) + { + viewer.evalStringQuiet("History " + ((debug || enable) ? "on" : "off")); + } + + public void loadInline(String string) + { + loadedInline = true; + // TODO: re JAL-623 + // viewer.loadInline(strModel, isAppend); + // could do this: + // construct fake fullPathName and fileName so we can identify the file + // later. + // Then, construct pass a reader for the string to Jmol. + // ((org.jmol.Viewer.Viewer) viewer).loadModelFromFile(fullPathName, + // fileName, null, reader, false, null, null, 0); + viewer.openStringInline(string); + } + + public void mouseOverStructure(int atomIndex, String strInfo) + { + int pdbResNum; + int alocsep = strInfo.indexOf("^"); + int mdlSep = strInfo.indexOf("/"); + int chainSeparator = strInfo.indexOf(":"), chainSeparator1 = -1; + + if (chainSeparator == -1) + { + chainSeparator = strInfo.indexOf("."); + if (mdlSep > -1 && mdlSep < chainSeparator) + { + chainSeparator1 = chainSeparator; + chainSeparator = mdlSep; + } + } + // handle insertion codes + if (alocsep != -1) + { + pdbResNum = Integer.parseInt(strInfo.substring( + strInfo.indexOf("]") + 1, alocsep)); + + } + else + { + pdbResNum = Integer.parseInt(strInfo.substring( + strInfo.indexOf("]") + 1, chainSeparator)); + } + String chainId; + + if (strInfo.indexOf(":") > -1) + chainId = strInfo.substring(strInfo.indexOf(":") + 1, + strInfo.indexOf(".")); + else + { + chainId = " "; + } + + String pdbfilename = modelFileNames[frameNo]; // default is first or current + // model + if (mdlSep > -1) + { + if (chainSeparator1 == -1) + { + chainSeparator1 = strInfo.indexOf(".", mdlSep); + } + String mdlId = (chainSeparator1 > -1) ? strInfo.substring(mdlSep + 1, + chainSeparator1) : strInfo.substring(mdlSep + 1); + try + { + // recover PDB filename for the model hovered over. + pdbfilename = viewer + .getModelFileName(new Integer(mdlId).intValue() - 1); + } catch (Exception e) + { + } + ; + } + if (lastMessage == null || !lastMessage.equals(strInfo)) + ssm.mouseOverStructure(pdbResNum, chainId, pdbfilename); + + lastMessage = strInfo; + } + + public void notifyAtomHovered(int atomIndex, String strInfo, String data) + { + if (data != null) + { + System.err.println("Ignoring additional hover info: " + data + + " (other info: '" + strInfo + "' pos " + atomIndex + ")"); + } + mouseOverStructure(atomIndex, strInfo); + } + + /* + * { if (history != null && strStatus != null && + * !strStatus.equals("Script completed")) { history.append("\n" + strStatus); + * } } + */ + + public void notifyAtomPicked(int atomIndex, String strInfo, String strData) + { + /** + * this implements the toggle label behaviour copied from the original + * structure viewer, MCView + */ + if (strData != null) + { + System.err.println("Ignoring additional pick data string " + strData); + } + int chainSeparator = strInfo.indexOf(":"); + int p = 0; + if (chainSeparator == -1) + chainSeparator = strInfo.indexOf("."); + + String picked = strInfo.substring(strInfo.indexOf("]") + 1, + chainSeparator); + String mdlString = ""; + if ((p = strInfo.indexOf(":")) > -1) + picked += strInfo.substring(p + 1, strInfo.indexOf(".")); + + if ((p = strInfo.indexOf("/")) > -1) + { + mdlString += strInfo.substring(p, strInfo.indexOf(" #")); + } + picked = "((" + picked + ".CA" + mdlString + ")|(" + picked + ".P" + + mdlString + "))"; + jmolHistory(false); + + if (!atomsPicked.contains(picked)) + { + viewer.evalStringQuiet("select " + picked + ";label %n %r:%c"); + atomsPicked.addElement(picked); + } + else + { + viewer.evalString("select " + picked + ";label off"); + atomsPicked.removeElement(picked); + } + jmolHistory(true); + // TODO: in application this happens + // + // if (scriptWindow != null) + // { + // scriptWindow.sendConsoleMessage(strInfo); + // scriptWindow.sendConsoleMessage("\n"); + // } + + } + + public void notifyCallback(int type, Object[] data) + { + try + { + switch (type) + { + case JmolConstants.CALLBACK_LOADSTRUCT: + notifyFileLoaded((String) data[1], (String) data[2], + (String) data[3], (String) data[4], + ((Integer) data[5]).intValue()); + + break; + case JmolConstants.CALLBACK_PICK: + notifyAtomPicked(((Integer) data[2]).intValue(), (String) data[1], + (String) data[0]); + // also highlight in alignment + case JmolConstants.CALLBACK_HOVER: + notifyAtomHovered(((Integer) data[2]).intValue(), (String) data[1], + (String) data[0]); + break; + case JmolConstants.CALLBACK_SCRIPT: + notifyScriptTermination((String) data[2], + ((Integer) data[3]).intValue()); + break; + case JmolConstants.CALLBACK_ECHO: + sendConsoleEcho((String) data[1]); + break; + case JmolConstants.CALLBACK_MESSAGE: + sendConsoleMessage((data == null) ? ((String) null) + : (String) data[1]); + break; + case JmolConstants.CALLBACK_ERROR: + // System.err.println("Ignoring error callback."); + break; + case JmolConstants.CALLBACK_SYNC: + case JmolConstants.CALLBACK_RESIZE: + refreshGUI(); + break; + case JmolConstants.CALLBACK_MEASURE: + + case JmolConstants.CALLBACK_CLICK: + default: + System.err.println("Unhandled callback " + type + " " + + data[1].toString()); + break; + } + } catch (Exception e) + { + System.err.println("Squashed Jmol callback handler error:"); + e.printStackTrace(); + } + } + + public boolean notifyEnabled(int callbackPick) + { + switch (callbackPick) + { + case JmolConstants.CALLBACK_ECHO: + case JmolConstants.CALLBACK_LOADSTRUCT: + case JmolConstants.CALLBACK_MEASURE: + case JmolConstants.CALLBACK_MESSAGE: + case JmolConstants.CALLBACK_PICK: + case JmolConstants.CALLBACK_SCRIPT: + case JmolConstants.CALLBACK_HOVER: + case JmolConstants.CALLBACK_ERROR: + return true; + case JmolConstants.CALLBACK_RESIZE: + case JmolConstants.CALLBACK_SYNC: + case JmolConstants.CALLBACK_CLICK: + case JmolConstants.CALLBACK_ANIMFRAME: + case JmolConstants.CALLBACK_MINIMIZATION: + } + return false; + } + + // incremented every time a load notification is successfully handled - + // lightweight mechanism for other threads to detect when they can start + // referrring to new structures. + private long loadNotifiesHandled = 0; + + public long getLoadNotifiesHandled() + { + return loadNotifiesHandled; + } + + public void notifyFileLoaded(String fullPathName, String fileName2, + String modelName, String errorMsg, int modelParts) + { + if (errorMsg != null) + { + fileLoadingError = errorMsg; + refreshGUI(); + return; + } + // TODO: deal sensibly with models loaded inLine: + // modelName will be null, as will fullPathName. + + // the rest of this routine ignores the arguments, and simply interrogates + // the Jmol view to find out what structures it contains, and adds them to + // the structure selection manager. + fileLoadingError = null; + String[] oldmodels = modelFileNames; + modelFileNames = null; + chainNames = new Vector(); + chainFile = new Hashtable(); + boolean notifyLoaded = false; + String[] modelfilenames = getPdbFile(); + // first check if we've lost any structures + if (oldmodels != null && oldmodels.length > 0) + { + int oldm = 0; + for (int i = 0; i < oldmodels.length; i++) + { + for (int n = 0; n < modelfilenames.length; n++) + { + if (modelfilenames[n] == oldmodels[i]) + { + oldmodels[i] = null; + break; + } + } + if (oldmodels[i] != null) + { + oldm++; + } + } + if (oldm > 0) + { + String[] oldmfn = new String[oldm]; + oldm = 0; + for (int i = 0; i < oldmodels.length; i++) + { + if (oldmodels[i] != null) + { + oldmfn[oldm++] = oldmodels[i]; + } + } + // deregister the Jmol instance for these structures - we'll add + // ourselves again at the end for the current structure set. + ssm.removeStructureViewerListener(this, oldmfn); + } + } + refreshPdbEntries(); + for (int modelnum = 0; modelnum < modelfilenames.length; modelnum++) + { + String fileName = modelfilenames[modelnum]; + boolean foundEntry = false; + MCview.PDBfile pdb = null; + String pdbfile = null, pdbfhash = null; + // model was probably loaded inline - so check the pdb file hashcode + if (loadedInline) + { + // calculate essential attributes for the pdb data imported inline. + // prolly need to resolve modelnumber properly - for now just use our + // 'best guess' + pdbfile = viewer.getData("" + (1 + _modelFileNameMap[modelnum]) + + ".0", "PDB"); + pdbfhash = "" + pdbfile.hashCode(); + } + if (pdbentry != null) + { + // search pdbentries and sequences to find correct pdbentry for this + // model + for (int pe = 0; pe < pdbentry.length; pe++) + { + boolean matches = false; + if (fileName == null) + { + if (false) + // see JAL-623 - need method of matching pasted data up + { + pdb = ssm.setMapping(sequence[pe], chains[pe], pdbfile, + AppletFormatAdapter.PASTE); + pdbentry[modelnum].setFile("INLINE" + pdb.id); + matches = true; + foundEntry = true; + } + } + else + { + if (matches = pdbentry[pe].getFile().equals(fileName)) + { + foundEntry = true; + // TODO: Jmol can in principle retrieve from CLASSLOADER but + // this + // needs + // to be tested. See mantis bug + // https://mantis.lifesci.dundee.ac.uk/view.php?id=36605 + String protocol = AppletFormatAdapter.URL; + try + { + File fl = new java.io.File(pdbentry[pe].getFile()); + if (fl.exists()) + { + protocol = AppletFormatAdapter.FILE; + } + } catch (Exception e) + { + } catch (Error e) + { + } + ; + pdb = ssm.setMapping(sequence[pe], chains[pe], + pdbentry[pe].getFile(), protocol); + + } + } + if (matches) + { + pdbentry[pe].setId(pdb.id); + // add an entry for every chain in the model + for (int i = 0; i < pdb.chains.size(); i++) + { + String chid = new String(pdb.id + ":" + + ((MCview.PDBChain) pdb.chains.elementAt(i)).id); + chainFile.put(chid, pdbentry[pe].getFile()); + chainNames.addElement(chid); + } + notifyLoaded = true; + } + } + } + if (!foundEntry && associateNewStructs) + { + // this is a foreign pdb file that jalview doesn't know about - add + // it to the dataset and try to find a home - either on a matching + // sequence or as a new sequence. + String pdbcontent = viewer.getData("/" + (modelnum + 1) + ".1", + "PDB"); + // parse pdb file into a chain, etc. + // locate best match for pdb in associated views and add mapping to + // ssm + // if properly registered then + notifyLoaded = true; + + } + } + // FILE LOADED OK + // so finally, update the jmol bits and pieces + if (jmolpopup != null) + { + // potential for deadlock here: + // jmolpopup.updateComputedMenus(); + } + if (!isLoadingFromArchive()) + { + viewer.evalStringQuiet("model 0; select backbone;restrict;cartoon;wireframe off;spacefill off"); + } + // register ourselves as a listener and notify the gui that it needs to + // update itself. + ssm.addStructureViewerListener(this); + if (notifyLoaded) + { + FeatureRenderer fr = getFeatureRenderer(null); + if (fr != null) + { + fr.featuresAdded(); + } + refreshGUI(); + loadNotifiesHandled++; + } + setLoadingFromArchive(false); + } + + public void notifyNewPickingModeMeasurement(int iatom, String strMeasure) + { + notifyAtomPicked(iatom, strMeasure, null); + } + + public abstract void notifyScriptTermination(String strStatus, + int msWalltime); + + /** + * display a message echoed from the jmol viewer + * + * @param strEcho + */ + public abstract void sendConsoleEcho(String strEcho); /* + * { showConsole(true); + * + * history.append("\n" + + * strEcho); } + */ + + // /End JmolStatusListener + // ///////////////////////////// + + /** + * @param strStatus + * status message - usually the response received after a script + * executed + */ + public abstract void sendConsoleMessage(String strStatus); + + public void setCallbackFunction(String callbackType, + String callbackFunction) + { + System.err.println("Ignoring set-callback request to associate " + + callbackType + " with function " + callbackFunction); + + } + + public void setJalviewColourScheme(ColourSchemeI cs) + { + colourBySequence = false; + + if (cs == null) + return; + + String res; + int index; + Color col; + jmolHistory(false); + // TODO: Switch between nucleotide or aa selection expressions + Enumeration en = ResidueProperties.aa3Hash.keys(); + StringBuffer command = new StringBuffer("select *;color white;"); + while (en.hasMoreElements()) + { + res = en.nextElement().toString(); + index = ((Integer) ResidueProperties.aa3Hash.get(res)).intValue(); + if (index > 20) + continue; + + col = cs.findColour(ResidueProperties.aa[index].charAt(0)); + + command.append("select " + res + ";color[" + col.getRed() + "," + + col.getGreen() + "," + col.getBlue() + "];"); + } + + evalStateCommand(command.toString()); + jmolHistory(true); + } + + public void showHelp() + { + showUrl("http://jmol.sourceforge.net/docs/JmolUserGuide/", "jmolHelp"); + } + + /** + * open the URL somehow + * + * @param target + */ + public abstract void showUrl(String url, String target); + + /** + * called when the binding thinks the UI needs to be refreshed after a Jmol + * state change. this could be because structures were loaded, or because an + * error has occured. + */ + public abstract void refreshGUI(); + + /** + * called to show or hide the associated console window container. + * + * @param show + */ + public abstract void showConsole(boolean show); + + /** + * @param renderPanel + * @param jmolfileio + * - when true will initialise jmol's file IO system (should be false + * in applet context) + * @param htmlName + * @param documentBase + * @param codeBase + * @param commandOptions + */ + public void allocateViewer(Container renderPanel, boolean jmolfileio, + String htmlName, URL documentBase, URL codeBase, + String commandOptions) + { + allocateViewer(renderPanel, jmolfileio, htmlName, documentBase, + codeBase, commandOptions, null, null); + } + + /** + * + * @param renderPanel + * @param jmolfileio + * - when true will initialise jmol's file IO system (should be false + * in applet context) + * @param htmlName + * @param documentBase + * @param codeBase + * @param commandOptions + * @param consolePanel + * - panel to contain Jmol console + * @param buttonsToShow + * - buttons to show on the console, in ordr + */ + public void allocateViewer(Container renderPanel, boolean jmolfileio, + String htmlName, URL documentBase, URL codeBase, + String commandOptions, final Container consolePanel, + String buttonsToShow) + { + if (commandOptions==null) { + commandOptions=""; + } + viewer = JmolViewer.allocateViewer(renderPanel, + (jmolfileio ? new SmarterJmolAdapter() : null), htmlName + + ((Object) this).toString(), documentBase, codeBase, + commandOptions, this); + + console = createJmolConsole(viewer, consolePanel, buttonsToShow); + if (consolePanel != null) + { + consolePanel.addComponentListener(this); + + } + + } + + protected abstract JmolAppConsoleInterface createJmolConsole( + JmolViewer viewer2, Container consolePanel, String buttonsToShow); + + protected org.jmol.api.JmolAppConsoleInterface console = null; + + public void componentResized(ComponentEvent e) + { + + } + + public void componentMoved(ComponentEvent e) + { + + } + + public void componentShown(ComponentEvent e) + { + showConsole(true); + } + + public void componentHidden(ComponentEvent e) + { + showConsole(false); + } + + public void setLoadingFromArchive(boolean loadingFromArchive) + { + this.loadingFromArchive = loadingFromArchive; + } + + public boolean isLoadingFromArchive() + { + return loadingFromArchive; + } + + public void setBackgroundColour(java.awt.Color col) + { + jmolHistory(false); + viewer.evalStringQuiet("background [" + col.getRed() + "," + + col.getGreen() + "," + col.getBlue() + "];"); + jmolHistory(true); + } + + /** + * add structures and any known sequence associations + * + * @returns the pdb entries added to the current set. + */ + public synchronized PDBEntry[] addSequenceAndChain(PDBEntry[] pdbe, + SequenceI[][] seq, String[][] chns) + { + int pe = -1; + Vector v = new Vector(); + Vector rtn = new Vector(); + for (int i = 0; i < pdbentry.length; i++) + { + v.addElement(pdbentry[i]); + } + for (int i = 0; i < pdbe.length; i++) + { + int r = v.indexOf(pdbe[i]); + if (r == -1 || r >= pdbentry.length) + { + rtn.addElement(new int[] + { v.size(), i }); + v.addElement(pdbe[i]); + } + else + { + // just make sure the sequence/chain entries are all up to date + addSequenceAndChain(r, seq[i], chns[i]); + } + } + pdbe = new PDBEntry[v.size()]; + v.copyInto(pdbe); + pdbentry = pdbe; + if (rtn.size() > 0) + { + // expand the tied seuqence[] and string[] arrays + SequenceI[][] sqs = new SequenceI[pdbentry.length][]; + String[][] sch = new String[pdbentry.length][]; + System.arraycopy(sequence, 0, sqs, 0, sequence.length); + System.arraycopy(chains, 0, sch, 0, this.chains.length); + sequence = sqs; + chains = sch; + pdbe = new PDBEntry[rtn.size()]; + for (int r = 0; r < pdbe.length; r++) + { + int[] stri = ((int[]) rtn.elementAt(r)); + // record the pdb file as a new addition + pdbe[r] = pdbentry[stri[0]]; + // and add the new sequence/chain entries + addSequenceAndChain(stri[0], seq[stri[1]], chns[stri[1]]); + } + } + else + { + pdbe = null; + } + return pdbe; + } + + public void addSequence(int pe, SequenceI[] seq) + { + // add sequences to the pe'th pdbentry's seuqence set. + addSequenceAndChain(pe, seq, null); + } + + private void addSequenceAndChain(int pe, SequenceI[] seq, String[] tchain) + { + if (pe < 0 || pe >= pdbentry.length) + { + throw new Error( + "Implementation error - no corresponding pdbentry (for index " + + pe + ") to add sequences mappings to"); + } + final String nullChain = "TheNullChain"; + Vector s = new Vector(); + Vector c = new Vector(); + if (chains == null) + { + chains = new String[pdbentry.length][]; + } + if (sequence[pe] != null) + { + for (int i = 0; i < sequence[pe].length; i++) + { + s.addElement(sequence[pe][i]); + if (chains[pe] != null) + { + if (i < chains[pe].length) + { + c.addElement(chains[pe][i]); + } + else + { + c.addElement(nullChain); + } + } + else + { + if (tchain != null && tchain.length > 0) + { + c.addElement(nullChain); + } + } + } + } + for (int i = 0; i < seq.length; i++) + { + if (!s.contains(seq[i])) + { + s.addElement(seq[i]); + if (tchain != null && i < tchain.length) + { + c.addElement(tchain[i] == null ? nullChain : tchain[i]); + } + } + } + SequenceI[] tmp = new SequenceI[s.size()]; + s.copyInto(tmp); + sequence[pe] = tmp; + if (c.size() > 0) + { + String[] tch = new String[c.size()]; + c.copyInto(tch); + for (int i = 0; i < tch.length; i++) + { + if (tch[i] == nullChain) + { + tch[i] = null; + } + } + chains[pe] = tch; + } + else + { + chains[pe] = null; + } + } + /** + * + * @param pdbfile + * @return text report of alignment between pdbfile and any associated alignment sequences + */ + public String printMapping(String pdbfile) + { + return ssm.printMapping(pdbfile); + } + +} diff --git a/src/jalview/ext/varna/VarnaCommands.java b/src/jalview/ext/varna/VarnaCommands.java new file mode 100644 index 0000000..9d57969 --- /dev/null +++ b/src/jalview/ext/varna/VarnaCommands.java @@ -0,0 +1,142 @@ +/** + * + */ +package jalview.ext.varna; + +import jalview.api.FeatureRenderer; +import jalview.api.SequenceRenderer; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.SequenceI; +import jalview.structure.StructureMapping; +import jalview.structure.StructureSelectionManager; +import jalview.util.Comparison; + +import java.awt.Color; +import java.util.ArrayList; + +/** + * Routines for generating Jmol commands for Jalview/Jmol binding + * another cruisecontrol test. + * + * @author JimP + * + */ +public class VarnaCommands +{ + + /** + * Jmol utility which constructs the commands to colour chains by the given alignment + * + */ + public static String[] getColourBySequenceCommand(StructureSelectionManager ssm, String[] files, SequenceI[][] sequence, SequenceRenderer sr, FeatureRenderer fr, AlignmentI alignment) + { + ArrayList str = new ArrayList(); + StringBuffer command = new StringBuffer(); + + for (int pdbfnum = 0; pdbfnum < files.length; pdbfnum++) + { + StructureMapping[] mapping = ssm.getMapping(files[pdbfnum]); + + if (mapping == null || mapping.length < 1) + continue; + + int lastPos = -1; + for (int s = 0; s < sequence[pdbfnum].length; s++) + { + for (int sp, m = 0; m < mapping.length; m++) + { + if (mapping[m].getSequence() == sequence[pdbfnum][s] + && (sp = alignment.findIndex(sequence[pdbfnum][s])) > -1) + { + SequenceI asp = alignment.getSequenceAt(sp); + for (int r = 0; r < asp.getLength(); r++) + { + // no mapping to gaps in sequence + if (jalview.util.Comparison.isGap(asp.getCharAt(r))) + { + continue; + } + int pos = mapping[m].getPDBResNum(asp.findPosition(r)); + + if (pos < 1 || pos == lastPos) + continue; + + lastPos = pos; + + Color col = sr.getResidueBoxColour(sequence[pdbfnum][s], r); + + if (fr != null) + col = fr.findFeatureColour(col, sequence[pdbfnum][s], r); + String newSelcom = (mapping[m].getChain() != " " ? ":" + + mapping[m].getChain() : "") + + "/" + + (pdbfnum + 1) + + ".1" + + ";color[" + + col.getRed() + + "," + + col.getGreen() + + "," + + col.getBlue() + "]"; + if (command.length()>newSelcom.length() && command.substring(command.length()-newSelcom.length()).equals(newSelcom)) + { + command = VarnaCommands.condenseCommand(command, pos); + continue; + } + // TODO: deal with case when buffer is too large for Jmol to parse + // - execute command and flush + + command.append(";"); + if (command.length()>51200) + { + // add another chunk + str.add(command.toString()); + command.setLength(0); + } + command.append("select " + pos); + command.append(newSelcom); + } + break; + } + } + } + } + { + // add final chunk + str.add(command.toString()); + command.setLength(0); + } + return str.toArray(new String[str.size()]); + } + + public static StringBuffer condenseCommand(StringBuffer command, int pos) + { + + // work back to last 'select' + int p=command.length(),q=p; + do { + p-=6; + if (p<1) { p=0; }; + } while ((q=command.indexOf("select",p))==-1 && p>0); + + StringBuffer sb = new StringBuffer(command.substring(0,q+7)); + + command = command.delete(0,q+7); + + String start; + + if (command.indexOf("-") > -1) + { + start = command.substring(0, command.indexOf("-")); + } + else + { + start = command.substring(0, command.indexOf(":")); + } + + sb.append(start + "-" + pos + command.substring(command.indexOf(":"))); + + return sb; + } + +} diff --git a/src/jalview/gui/AppVarna.java b/src/jalview/gui/AppVarna.java new file mode 100644 index 0000000..7b388fc --- /dev/null +++ b/src/jalview/gui/AppVarna.java @@ -0,0 +1,1294 @@ +/* + * 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.gui; + +import java.util.*; +import java.awt.*; +import javax.swing.*; +import javax.swing.event.*; + +import java.awt.event.*; +import java.io.*; + +import jalview.jbgui.GStructureViewer; +import jalview.api.SequenceStructureBinding; +import jalview.bin.Cache; +import jalview.datamodel.*; +import jalview.gui.ViewSelectionMenu.ViewSetProvider; +import jalview.structure.*; +import jalview.datamodel.PDBEntry; +import jalview.io.*; +import jalview.schemes.*; + +public class AppVarna extends GStructureViewer implements Runnable, + SequenceStructureBinding, ViewSetProvider + +{ + AppJmolBinding jmb; + + JPanel scriptWindow; + + JSplitPane splitPane; + + RenderPanel renderPanel; + + AlignmentPanel ap; + + Vector atomsPicked = new Vector(); + + private boolean addingStructures = false; + + /** + * + * @param file + * @param id + * @param seq + * @param ap + * @param loadStatus + * @param bounds + * @deprecated defaults to AppJmol(String[] files, ... , viewid); + */ + public AppVarna(String file, String id, SequenceI[] seq, + AlignmentPanel ap, String loadStatus, Rectangle bounds) + { + this(file, id, seq, ap, loadStatus, bounds, null); + } + + /** + * @deprecated + */ + public AppVarna(String file, String id, SequenceI[] seq, + AlignmentPanel ap, String loadStatus, Rectangle bounds, + String viewid) + { + this(new String[] + { file }, new String[] + { id }, new SequenceI[][] + { seq }, ap, true, true, false, loadStatus, bounds, viewid); + } + + ViewSelectionMenu seqColourBy; + + /** + * + * @param files + * @param ids + * @param seqs + * @param ap + * @param usetoColour + * - add the alignment panel to the list used for colouring these + * structures + * @param useToAlign + * - add the alignment panel to the list used for aligning these + * structures + * @param leaveColouringToJmol + * - do not update the colours from any other source. Jmol is handling them + * @param loadStatus + * @param bounds + * @param viewid + */ + public AppVarna(String[] files, String[] ids, SequenceI[][] seqs, + AlignmentPanel ap, boolean usetoColour, boolean useToAlign, boolean leaveColouringToJmol, + String loadStatus, Rectangle bounds, String viewid) + { + PDBEntry[] pdbentrys = new PDBEntry[files.length]; + for (int i = 0; i < pdbentrys.length; i++) + { + PDBEntry pdbentry = new PDBEntry(); + pdbentry.setFile(files[i]); + pdbentry.setId(ids[i]); + pdbentrys[i] = pdbentry; + } + // / TODO: check if protocol is needed to be set, and if chains are + // autodiscovered. + jmb = new AppJmolBinding(this, ap.getStructureSelectionManager(), pdbentrys, seqs, null, null); + + jmb.setLoadingFromArchive(true); + addAlignmentPanel(ap); + if (useToAlign) + { + useAlignmentPanelForSuperposition(ap); + } + if (leaveColouringToJmol || !usetoColour) + { + jmb.setColourBySequence(false); + seqColour.setSelected(false); + jmolColour.setSelected(true); + } + if (usetoColour) + { + useAlignmentPanelForColourbyseq(ap); + jmb.setColourBySequence(true); + seqColour.setSelected(true); + jmolColour.setSelected(false); + } + this.setBounds(bounds); + initMenus(); + viewId = viewid; + // jalview.gui.Desktop.addInternalFrame(this, "Loading File", + // bounds.width,bounds.height); + + this.addInternalFrameListener(new InternalFrameAdapter() + { + public void internalFrameClosing(InternalFrameEvent internalFrameEvent) + { + closeViewer(); + } + }); + initJmol(loadStatus); // pdbentry, seq, JBPCHECK! + + } + + private void initMenus() + { + seqColour.setSelected(jmb.isColourBySequence()); + jmolColour.setSelected(!jmb.isColourBySequence()); + if (_colourwith==null) + { + _colourwith=new Vector(); + } + if (_alignwith==null) + { + _alignwith=new Vector(); + } + + seqColourBy = new ViewSelectionMenu("Colour by ..", this, _colourwith, + new ItemListener() + { + + @Override + public void itemStateChanged(ItemEvent e) + { + if (!seqColour.isSelected()) + { + seqColour.doClick(); + } + else + { + // update the jmol display now. + seqColour_actionPerformed(null); + } + } + }); + viewMenu.add(seqColourBy); + final ItemListener handler; + JMenu alpanels = new ViewSelectionMenu("Superpose with ..", this, + _alignwith, handler = new ItemListener() + { + + @Override + public void itemStateChanged(ItemEvent e) + { + alignStructs.setEnabled(_alignwith.size() > 0); + alignStructs.setToolTipText("Align structures using " + + _alignwith.size() + " linked alignment views"); + } + }); + handler.itemStateChanged(null); + jmolActionMenu.add(alpanels); + jmolActionMenu.addMenuListener(new MenuListener() + { + + @Override + public void menuSelected(MenuEvent e) + { + handler.itemStateChanged(null); + } + + @Override + public void menuDeselected(MenuEvent e) + { + // TODO Auto-generated method stub + + } + + @Override + public void menuCanceled(MenuEvent e) + { + // TODO Auto-generated method stub + + } + }); + } + IProgressIndicator progressBar = null; + + public AppVarna(PDBEntry pdbentry, SequenceI[] seq, String[] chains, + AlignmentPanel ap) + { + progressBar = ap.alignFrame; + // //////////////////////////////// + // Is the pdb file already loaded? + String alreadyMapped = jmb.ssm.alreadyMappedToFile( + pdbentry.getId()); + + if (alreadyMapped != null) + { + int option = JOptionPane.showInternalConfirmDialog(Desktop.desktop, + pdbentry.getId() + " is already displayed." + + "\nDo you want to re-use this viewer ?", + "Map Sequences to Visible Window: " + pdbentry.getId(), + JOptionPane.YES_NO_OPTION); + + if (option == JOptionPane.YES_OPTION) + { + jmb.ssm.setMapping(seq, chains, alreadyMapped, + AppletFormatAdapter.FILE); + if (ap.seqPanel.seqCanvas.fr != null) + { + ap.seqPanel.seqCanvas.fr.featuresAdded(); + ap.paintAlignment(true); + } + + // Now this AppJmol is mapped to new sequences. We must add them to + // the exisiting array + JInternalFrame[] frames = Desktop.instance.getAllFrames(); + + for (int i = 0; i < frames.length; i++) + { + if (frames[i] instanceof AppVarna) + { + AppVarna topJmol = ((AppVarna) frames[i]); + // JBPNOTE: this looks like a binding routine, rather than a gui + // routine + for (int pe = 0; pe < topJmol.jmb.pdbentry.length; pe++) + { + if (topJmol.jmb.pdbentry[pe].getFile().equals(alreadyMapped)) + { + topJmol.jmb.addSequence(pe, seq); + topJmol.addAlignmentPanel(ap); + topJmol.buildJmolActionMenu(); + break; + } + } + } + } + + return; + } + } + // ///////////////////////////////// + // Check if there are other Jmol views involving this alignment + // and prompt user about adding this molecule to one of them + Vector existingViews = getJmolsFor(ap); + if (existingViews.size() > 0) + { + Enumeration jm = existingViews.elements(); + while (jm.hasMoreElements()) + { + AppVarna topJmol = (AppVarna) jm.nextElement(); + // TODO: highlight topJmol in view somehow + int option = JOptionPane.showInternalConfirmDialog(Desktop.desktop, + "Do you want to add " + pdbentry.getId() + + " to the view called\n'" + topJmol.getTitle() + + "'\n", "Align to existing structure view", + JOptionPane.YES_NO_OPTION); + if (option == JOptionPane.YES_OPTION) + { + topJmol.useAlignmentPanelForSuperposition(ap); + topJmol.addStructure(pdbentry, seq, chains, true, ap.alignFrame); + return; + } + } + } + // ///////////////////////////////// + + jmb = new AppJmolBinding(this, ap.getStructureSelectionManager(), new PDBEntry[] + { pdbentry }, new SequenceI[][] + { seq }, null, null); + addAlignmentPanel(ap); + useAlignmentPanelForColourbyseq(ap); + jmb.setColourBySequence(true); + setSize(400, 400); // probably should be a configurable/dynamic default here + initMenus(); + + if (pdbentry.getFile() != null) + { + initJmol("load \"" + pdbentry.getFile() + "\""); + } + else + { + addingStructures = false; + worker = new Thread(this); + worker.start(); + } + + this.addInternalFrameListener(new InternalFrameAdapter() + { + public void internalFrameClosing(InternalFrameEvent internalFrameEvent) + { + closeViewer(); + } + }); + + } + + /** + * list of sequenceSet ids associated with the view + */ + ArrayList _aps = new ArrayList(); + + public AlignmentPanel[] getAllAlignmentPanels() + { + AlignmentPanel[] t, list = new AlignmentPanel[0]; + for (String setid : _aps) + { + AlignmentPanel[] panels = PaintRefresher.getAssociatedPanels(setid); + if (panels != null) + { + t = new AlignmentPanel[list.length + panels.length]; + System.arraycopy(list, 0, t, 0, list.length); + System.arraycopy(panels, 0, t, list.length, panels.length); + list = t; + } + } + + return list; + } + + /** + * list of alignment panels to use for superposition + */ + Vector _alignwith = new Vector(); + + /** + * list of alignment panels that are used for colouring structures by aligned + * sequences + */ + Vector _colourwith = new Vector(); + + /** + * set the primary alignmentPanel reference and add another alignPanel to the + * list of ones to use for colouring and aligning + * + * @param nap + */ + public void addAlignmentPanel(AlignmentPanel nap) + { + if (ap == null) + { + ap = nap; + } + if (!_aps.contains(nap.av.getSequenceSetId())) + { + _aps.add(nap.av.getSequenceSetId()); + } + } + + /** + * remove any references held to the given alignment panel + * + * @param nap + */ + public void removeAlignmentPanel(AlignmentPanel nap) + { + try + { + _alignwith.remove(nap); + _colourwith.remove(nap); + if (ap == nap) + { + ap = null; + for (AlignmentPanel aps : getAllAlignmentPanels()) + { + if (aps != nap) + { + ap = aps; + break; + } + } + } + } catch (Exception ex) + { + } + if (ap != null) + { + buildJmolActionMenu(); + } + } + + public void useAlignmentPanelForSuperposition(AlignmentPanel nap) + { + addAlignmentPanel(nap); + if (!_alignwith.contains(nap)) + { + _alignwith.add(nap); + } + } + + public void excludeAlignmentPanelForSuperposition(AlignmentPanel nap) + { + if (_alignwith.contains(nap)) + { + _alignwith.remove(nap); + } + } + + public void useAlignmentPanelForColourbyseq(AlignmentPanel nap, boolean enableColourBySeq) + { + useAlignmentPanelForColourbyseq(nap); + jmb.setColourBySequence(enableColourBySeq); + seqColour.setSelected(enableColourBySeq); + jmolColour.setSelected(!enableColourBySeq); + } + public void useAlignmentPanelForColourbyseq(AlignmentPanel nap) + { + addAlignmentPanel(nap); + if (!_colourwith.contains(nap)) + { + _colourwith.add(nap); + } + } + + public void excludeAlignmentPanelForColourbyseq(AlignmentPanel nap) + { + if (_colourwith.contains(nap)) + { + _colourwith.remove(nap); + } + } + + /** + * pdb retrieval thread. + */ + private Thread worker = null; + + /** + * add a new structure (with associated sequences and chains) to this viewer, + * retrieving it if necessary first. + * + * @param pdbentry + * @param seq + * @param chains + * @param alignFrame + * @param align + * if true, new structure(s) will be align using associated alignment + */ + private void addStructure(final PDBEntry pdbentry, final SequenceI[] seq, + final String[] chains, final boolean b, + final IProgressIndicator alignFrame) + { + if (pdbentry.getFile() == null) + { + if (worker != null && worker.isAlive()) + { + // a retrieval is in progress, wait around and add ourselves to the + // queue. + new Thread(new Runnable() + { + public void run() + { + while (worker != null && worker.isAlive() && _started) + { + try + { + Thread.sleep(100 + ((int) Math.random() * 100)); + + } catch (Exception e) + { + } + + } + // and call ourselves again. + addStructure(pdbentry, seq, chains, b, alignFrame); + } + }).start(); + return; + } + } + // otherwise, start adding the structure. + jmb.addSequenceAndChain(new PDBEntry[] + { pdbentry }, new SequenceI[][] + { seq }, new String[][] + { chains }); + addingStructures = true; + _started = false; + alignAddedStructures = b; + progressBar = alignFrame; // visual indication happens on caller frame. + (worker = new Thread(this)).start(); + return; + } + + private Vector getJmolsFor(AlignmentPanel ap2) + { + Vector otherJmols = new Vector(); + // Now this AppJmol is mapped to new sequences. We must add them to + // the exisiting array + JInternalFrame[] frames = Desktop.instance.getAllFrames(); + + for (int i = 0; i < frames.length; i++) + { + if (frames[i] instanceof AppVarna) + { + AppVarna topJmol = ((AppVarna) frames[i]); + if (topJmol.isLinkedWith(ap2)) + { + otherJmols.addElement(topJmol); + } + } + } + return otherJmols; + } + + void initJmol(String command) + { + jmb.setFinishedInit(false); + renderPanel = new RenderPanel(); + // TODO: consider waiting until the structure/view is fully loaded before + // displaying + this.getContentPane().add(renderPanel, java.awt.BorderLayout.CENTER); + jalview.gui.Desktop.addInternalFrame(this, jmb.getViewerTitle(), + getBounds().width, getBounds().height); + if (scriptWindow == null) + { + BorderLayout bl = new BorderLayout(); + bl.setHgap(0); + bl.setVgap(0); + scriptWindow = new JPanel(bl); + scriptWindow.setVisible(false); + } + ; + jmb.allocateViewer(renderPanel, true, "", null, null, "", scriptWindow, + null); + jmb.newJmolPopup(true, "Jmol", true); + if (command==null) + { + command=""; + } + jmb.evalStateCommand(command); + jmb.setFinishedInit(true); + } + + void setChainMenuItems(Vector chains) + { + chainMenu.removeAll(); + if (chains == null) + { + return; + } + JMenuItem menuItem = new JMenuItem("All"); + menuItem.addActionListener(new ActionListener() + { + public void actionPerformed(ActionEvent evt) + { + allChainsSelected = true; + for (int i = 0; i < chainMenu.getItemCount(); i++) + { + if (chainMenu.getItem(i) instanceof JCheckBoxMenuItem) + ((JCheckBoxMenuItem) chainMenu.getItem(i)).setSelected(true); + } + centerViewer(); + allChainsSelected = false; + } + }); + + chainMenu.add(menuItem); + + for (int c = 0; c < chains.size(); c++) + { + menuItem = new JCheckBoxMenuItem(chains.elementAt(c).toString(), true); + menuItem.addItemListener(new ItemListener() + { + public void itemStateChanged(ItemEvent evt) + { + if (!allChainsSelected) + centerViewer(); + } + }); + + chainMenu.add(menuItem); + } + } + + boolean allChainsSelected = false; + + private boolean alignAddedStructures = false; + + void centerViewer() + { + Vector toshow = new Vector(); + String lbl; + int mlength, p, mnum; + for (int i = 0; i < chainMenu.getItemCount(); i++) + { + if (chainMenu.getItem(i) instanceof JCheckBoxMenuItem) + { + JCheckBoxMenuItem item = (JCheckBoxMenuItem) chainMenu.getItem(i); + if (item.isSelected()) + { + toshow.addElement(item.getText()); + } + } + } + jmb.centerViewer(toshow); + } + + void closeViewer() + { + jmb.closeViewer(); + ap = null; + _aps.clear(); + _alignwith.clear(); + _colourwith.clear(); + // TODO: check for memory leaks where instance isn't finalised because jmb + // holds a reference to the window + jmb = null; + } + + /** + * state flag for PDB retrieval thread + */ + private boolean _started = false; + + public void run() + { + _started = true; + String pdbid = ""; + // todo - record which pdbids were successfuly imported. + StringBuffer errormsgs = new StringBuffer(), files = new StringBuffer(); + try + { + String[] curfiles = jmb.getPdbFile(); // files currently in viewer + // TODO: replace with reference fetching/transfer code (validate PDBentry + // as a DBRef?) + jalview.ws.dbsources.Pdb pdbclient = new jalview.ws.dbsources.Pdb(); + for (int pi = 0; pi < jmb.pdbentry.length; pi++) + { + String file = jmb.pdbentry[pi].getFile(); + if (file == null) + { + // retrieve the pdb and store it locally + AlignmentI pdbseq = null; + pdbid = jmb.pdbentry[pi].getId(); + long hdl = pdbid.hashCode() - System.currentTimeMillis(); + if (progressBar != null) + { + progressBar.setProgressBar("Fetching PDB " + pdbid, hdl); + } + try + { + pdbseq = pdbclient.getSequenceRecords(pdbid = jmb.pdbentry[pi] + .getId()); + } catch (OutOfMemoryError oomerror) + { + new OOMWarning("Retrieving PDB id " + pdbid, oomerror); + } catch (Exception ex) + { + ex.printStackTrace(); + errormsgs.append("'" + pdbid + "'"); + } + if (progressBar != null) + { + progressBar.setProgressBar("Finished.", hdl); + } + if (pdbseq != null) + { + // just transfer the file name from the first sequence's first + // PDBEntry + jmb.pdbentry[pi].setFile(file = ((PDBEntry) pdbseq + .getSequenceAt(0).getPDBId().elementAt(0)).getFile()); + files.append(" \"" + file + "\""); + } + else + { + errormsgs.append("'" + pdbid + "' "); + } + } + else + { + if (curfiles != null && curfiles.length > 0) + { + addingStructures = true; // already files loaded. + for (int c = 0; c < curfiles.length; c++) + { + if (curfiles[c].equals(file)) + { + file = null; + break; + } + } + } + if (file != null) + { + files.append(" \"" + file + "\""); + } + } + } + } catch (OutOfMemoryError oomerror) + { + new OOMWarning("Retrieving PDB files: " + pdbid, oomerror); + } catch (Exception ex) + { + ex.printStackTrace(); + errormsgs.append("When retrieving pdbfiles : current was: '" + pdbid + + "'"); + } + if (errormsgs.length() > 0) + { + + JOptionPane.showInternalMessageDialog(Desktop.desktop, + "The following pdb entries could not be retrieved from the PDB:\n" + + errormsgs.toString() + + "\nPlease try downloading them manually.", + "Couldn't load file", JOptionPane.ERROR_MESSAGE); + + } + if (files.length() > 0) + { + if (!addingStructures) + { + + try + { + initJmol("load FILES " + files.toString()); + } catch (OutOfMemoryError oomerror) + { + new OOMWarning("When trying to open the Jmol viewer!", oomerror); + Cache.log.debug("File locations are " + files); + } catch (Exception ex) + { + Cache.log.error("Couldn't open Jmol viewer!", ex); + } + } + else + { + StringBuffer cmd = new StringBuffer(); + cmd.append("loadingJalviewdata=true\nload APPEND "); + cmd.append(files.toString()); + cmd.append("\nloadingJalviewdata=null"); + final String command = cmd.toString(); + cmd = null; + long lastnotify = jmb.getLoadNotifiesHandled(); + try + { + jmb.evalStateCommand(command); + } catch (OutOfMemoryError oomerror) + { + new OOMWarning( + "When trying to add structures to the Jmol viewer!", + oomerror); + Cache.log.debug("File locations are " + files); + } catch (Exception ex) + { + Cache.log.error("Couldn't add files to Jmol viewer!", ex); + } + // need to wait around until script has finished + while (lastnotify >= jmb.getLoadNotifiesHandled()) + ; + { + try + { + Thread.sleep(35); + } catch (Exception e) + { + } + } + // refresh the sequence colours for the new structure(s) + for (AlignmentPanel ap : _colourwith) + { + jmb.updateColours(ap); + } + // do superposition if asked to + if (alignAddedStructures) + { + javax.swing.SwingUtilities.invokeLater(new Runnable() + { + public void run() + { + alignStructs_withAllAlignPanels(); + // jmb.superposeStructures(ap.av.getAlignment(), -1, null); + } + }); + alignAddedStructures = false; + } + addingStructures = false; + } + } + _started = false; + worker = null; + } + + public void pdbFile_actionPerformed(ActionEvent actionEvent) + { + JalviewFileChooser chooser = new JalviewFileChooser( + jalview.bin.Cache.getProperty("LAST_DIRECTORY")); + + chooser.setFileView(new JalviewFileView()); + chooser.setDialogTitle("Save PDB File"); + chooser.setToolTipText("Save"); + + int value = chooser.showSaveDialog(this); + + if (value == JalviewFileChooser.APPROVE_OPTION) + { + try + { + // TODO: cope with multiple PDB files in view + BufferedReader in = new BufferedReader(new FileReader( + jmb.getPdbFile()[0])); + File outFile = chooser.getSelectedFile(); + + PrintWriter out = new PrintWriter(new FileOutputStream(outFile)); + String data; + while ((data = in.readLine()) != null) + { + if (!(data.indexOf("
") > -1 || data.indexOf("
") > -1)) + { + out.println(data); + } + } + out.close(); + } catch (Exception ex) + { + ex.printStackTrace(); + } + } + } + + public void viewMapping_actionPerformed(ActionEvent actionEvent) + { + jalview.gui.CutAndPasteTransfer cap = new jalview.gui.CutAndPasteTransfer(); + try + { + for (int pdbe = 0; pdbe < jmb.pdbentry.length; pdbe++) + { + cap.appendText(jmb.printMapping( + jmb.pdbentry[pdbe].getFile())); + cap.appendText("\n"); + } + } catch (OutOfMemoryError e) + { + new OOMWarning( + "composing sequence-structure alignments for display in text box.", + e); + cap.dispose(); + return; + } + jalview.gui.Desktop.addInternalFrame(cap, "PDB - Sequence Mapping", + 550, 600); + } + + /** + * DOCUMENT ME! + * + * @param e + * DOCUMENT ME! + */ + public void eps_actionPerformed(ActionEvent e) + { + makePDBImage(jalview.util.ImageMaker.EPS); + } + + /** + * DOCUMENT ME! + * + * @param e + * DOCUMENT ME! + */ + public void png_actionPerformed(ActionEvent e) + { + makePDBImage(jalview.util.ImageMaker.PNG); + } + + void makePDBImage(int type) + { + int width = getWidth(); + int height = getHeight(); + + jalview.util.ImageMaker im; + + if (type == jalview.util.ImageMaker.PNG) + { + im = new jalview.util.ImageMaker(this, jalview.util.ImageMaker.PNG, + "Make PNG image from view", width, height, null, null); + } + else + { + im = new jalview.util.ImageMaker(this, jalview.util.ImageMaker.EPS, + "Make EPS file from view", width, height, null, + this.getTitle()); + } + + if (im.getGraphics() != null) + { + Rectangle rect = new Rectangle(width, height); + jmb.viewer.renderScreenImage(im.getGraphics(), rect.getSize(), rect); + im.writeImage(); + } + } + public void jmolColour_actionPerformed(ActionEvent actionEvent) + { + if (jmolColour.isSelected()) { + // disable automatic sequence colouring. + jmb.setColourBySequence(false); + } + } + public void seqColour_actionPerformed(ActionEvent actionEvent) + { + jmb.setColourBySequence(seqColour.isSelected()); + if (_colourwith == null) + { + _colourwith = new Vector(); + } + if (jmb.isColourBySequence()) + { + if (!jmb.isLoadingFromArchive()) + { + if (_colourwith.size()==0 && ap!=null) { + // Make the currently displayed alignment panel the associated view + _colourwith.add(ap.alignFrame.alignPanel); + } + } + // Set the colour using the current view for the associated alignframe + for (AlignmentPanel ap : _colourwith) + { + jmb.colourBySequence(ap.av.showSequenceFeatures, ap); + } + } + } + + public void chainColour_actionPerformed(ActionEvent actionEvent) + { + chainColour.setSelected(true); + jmb.colourByChain(); + } + + public void chargeColour_actionPerformed(ActionEvent actionEvent) + { + chargeColour.setSelected(true); + jmb.colourByCharge(); + } + + public void zappoColour_actionPerformed(ActionEvent actionEvent) + { + zappoColour.setSelected(true); + jmb.setJalviewColourScheme(new ZappoColourScheme()); + } + + public void taylorColour_actionPerformed(ActionEvent actionEvent) + { + taylorColour.setSelected(true); + jmb.setJalviewColourScheme(new TaylorColourScheme()); + } + + public void hydroColour_actionPerformed(ActionEvent actionEvent) + { + hydroColour.setSelected(true); + jmb.setJalviewColourScheme(new HydrophobicColourScheme()); + } + + public void helixColour_actionPerformed(ActionEvent actionEvent) + { + helixColour.setSelected(true); + jmb.setJalviewColourScheme(new HelixColourScheme()); + } + + public void strandColour_actionPerformed(ActionEvent actionEvent) + { + strandColour.setSelected(true); + jmb.setJalviewColourScheme(new StrandColourScheme()); + } + + public void turnColour_actionPerformed(ActionEvent actionEvent) + { + turnColour.setSelected(true); + jmb.setJalviewColourScheme(new TurnColourScheme()); + } + + public void buriedColour_actionPerformed(ActionEvent actionEvent) + { + buriedColour.setSelected(true); + jmb.setJalviewColourScheme(new BuriedColourScheme()); + } + + public void purinePyrimidineColour_actionPerformed(ActionEvent actionEvent) + { + setJalviewColourScheme(new PurinePyrimidineColourScheme()); + } + + public void userColour_actionPerformed(ActionEvent actionEvent) + { + userColour.setSelected(true); + new UserDefinedColours(this, null); + } + + public void backGround_actionPerformed(ActionEvent actionEvent) + { + java.awt.Color col = JColorChooser.showDialog(this, + "Select Background Colour", null); + if (col != null) + { + jmb.setBackgroundColour(col); + } + } + + public void jmolHelp_actionPerformed(ActionEvent actionEvent) + { + try + { + jalview.util.BrowserLauncher + .openURL("http://jmol.sourceforge.net/docs/JmolUserGuide/"); + } catch (Exception ex) + { + } + } + + public void showConsole(boolean showConsole) + { + + if (showConsole) + { + if (splitPane == null) + { + splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT); + splitPane.setTopComponent(renderPanel); + splitPane.setBottomComponent(scriptWindow); + this.getContentPane().add(splitPane, BorderLayout.CENTER); + splitPane.setDividerLocation(getHeight() - 200); + scriptWindow.setVisible(true); + scriptWindow.validate(); + splitPane.validate(); + } + + } + else + { + if (splitPane != null) + { + splitPane.setVisible(false); + } + + splitPane = null; + + this.getContentPane().add(renderPanel, BorderLayout.CENTER); + } + + validate(); + } + + class RenderPanel extends JPanel + { + final Dimension currentSize = new Dimension(); + + final Rectangle rectClip = new Rectangle(); + + public void paintComponent(Graphics g) + { + getSize(currentSize); + g.getClipBounds(rectClip); + + if (jmb.fileLoadingError != null) + { + g.setColor(Color.black); + g.fillRect(0, 0, currentSize.width, currentSize.height); + g.setColor(Color.white); + g.setFont(new Font("Verdana", Font.BOLD, 14)); + g.drawString("Error loading file...", 20, currentSize.height / 2); + StringBuffer sb = new StringBuffer(); + int lines = 0; + for (int e = 0; e < jmb.pdbentry.length; e++) + { + sb.append(jmb.pdbentry[e].getId()); + if (e < jmb.pdbentry.length - 1) + { + sb.append(","); + } + + if (e == jmb.pdbentry.length - 1 || sb.length() > 20) + { + lines++; + g.drawString(sb.toString(), 20, currentSize.height / 2 - lines + * g.getFontMetrics().getHeight()); + } + } + } + else if (jmb == null || jmb.viewer == null || !jmb.isFinishedInit()) + { + g.setColor(Color.black); + g.fillRect(0, 0, currentSize.width, currentSize.height); + g.setColor(Color.white); + g.setFont(new Font("Verdana", Font.BOLD, 14)); + g.drawString("Retrieving PDB data....", 20, currentSize.height / 2); + } + else + { + jmb.viewer.renderScreenImage(g, currentSize, rectClip); + } + } + } + + String viewId = null; + + public String getViewId() + { + if (viewId == null) + { + viewId = System.currentTimeMillis() + "." + this.hashCode(); + } + return viewId; + } + + public void updateTitleAndMenus() + { + if (jmb.fileLoadingError != null && jmb.fileLoadingError.length() > 0) + { + repaint(); + return; + } + setChainMenuItems(jmb.chainNames); + + this.setTitle(jmb.getViewerTitle()); + if (jmb.getPdbFile().length > 1 && jmb.sequence.length > 1) + { + jmolActionMenu.setVisible(true); + } + if (!jmb.isLoadingFromArchive()) + { + seqColour_actionPerformed(null); + } + } + + protected void buildJmolActionMenu() + { + if (_alignwith == null) + { + _alignwith = new Vector(); + } + if (_alignwith.size() == 0 && ap != null) + { + _alignwith.add(ap); + } + ; + for (Component c : jmolActionMenu.getMenuComponents()) + { + if (c != alignStructs) + { + jmolActionMenu.remove((JMenuItem) c); + } + } + final ItemListener handler; + } + + /* + * (non-Javadoc) + * + * @see + * jalview.jbgui.GStructureViewer#alignStructs_actionPerformed(java.awt.event + * .ActionEvent) + */ + @Override + protected void alignStructs_actionPerformed(ActionEvent actionEvent) + { + alignStructs_withAllAlignPanels(); + } + + private void alignStructs_withAllAlignPanels() + { + if (ap == null) + { + return; + } + ; + if (_alignwith.size() == 0) + { + _alignwith.add(ap); + } + ; + try + { + AlignmentI[] als = new Alignment[_alignwith.size()]; + ColumnSelection[] alc = new ColumnSelection[_alignwith.size()]; + int[] alm = new int[_alignwith.size()]; + int a = 0; + + for (AlignmentPanel ap : _alignwith) + { + als[a] = ap.av.getAlignment(); + alm[a] = -1; + alc[a++] = ap.av.getColumnSelection(); + } + jmb.superposeStructures(als, alm, alc); + } catch (Exception e) + { + StringBuffer sp = new StringBuffer(); + for (AlignmentPanel ap : _alignwith) + { + sp.append("'" + ap.alignFrame.getTitle() + "' "); + } + Cache.log.info("Couldn't align structures with the " + sp.toString() + + "associated alignment panels.", e); + + } + + } + + public void setJalviewColourScheme(ColourSchemeI ucs) + { + jmb.setJalviewColourScheme(ucs); + + } + + /** + * + * @param alignment + * @return first alignment panel displaying given alignment, or the default + * alignment panel + */ + public AlignmentPanel getAlignmentPanelFor(AlignmentI alignment) + { + for (AlignmentPanel ap : getAllAlignmentPanels()) + { + if (ap.av.getAlignment() == alignment) + { + return ap; + } + } + return ap; + } + + /** + * + * @param ap2 + * @return true if this Jmol instance is linked with the given alignPanel + */ + public boolean isLinkedWith(AlignmentPanel ap2) + { + return _aps.contains(ap2.av.getSequenceSetId()); + } + + public boolean isUsedforaligment(AlignmentPanel ap2) + { + + return (_alignwith != null) && _alignwith.contains(ap2); + } + + public boolean isUsedforcolourby(AlignmentPanel ap2) + { + return (_colourwith != null) && _colourwith.contains(ap2); + } + + /** + * + * @return TRUE if the view is NOT being coloured by sequence associations. + */ + public boolean isColouredByJmol() + { + return !jmb.isColourBySequence(); + } + + +} diff --git a/src/jalview/gui/AppVarnaBinding.java b/src/jalview/gui/AppVarnaBinding.java new file mode 100644 index 0000000..105dd39 --- /dev/null +++ b/src/jalview/gui/AppVarnaBinding.java @@ -0,0 +1,230 @@ +/* + * 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.gui; + +import java.awt.Container; +import java.awt.event.ComponentEvent; +import java.awt.event.ComponentListener; +import java.awt.event.ContainerEvent; +import java.awt.event.ContainerListener; +import java.util.BitSet; + +import javax.swing.JPanel; + +import jalview.api.AlignmentViewPanel; +import jalview.bin.Cache; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.PDBEntry; +import jalview.datamodel.SequenceI; +import jalview.structure.StructureSelectionManager; + +import org.jmol.api.JmolAppConsoleInterface; +import org.jmol.api.JmolViewer; +import org.jmol.popup.JmolPopup; +import org.openscience.jmol.app.jmolpanel.AppConsole; + +public class AppVarnaBinding extends jalview.ext.jmol.JalviewJmolBinding +{ + + /** + * + */ + private AppJmol appJmolWindow; + + public AppVarnaBinding(AppJmol appJmol, StructureSelectionManager sSm, PDBEntry[] pdbentry, + SequenceI[][] sequenceIs, String[][] chains, String protocol) + { + super(sSm, pdbentry, sequenceIs, chains, protocol); + appJmolWindow = appJmol; + } + + FeatureRenderer fr = null; + + @Override + public jalview.api.FeatureRenderer getFeatureRenderer(AlignmentViewPanel alignment) + { + AlignmentPanel ap = (alignment==null) ? appJmolWindow.ap : (AlignmentPanel) alignment; + if (ap.av.showSequenceFeatures) + { + if (fr == null) + { + fr = new FeatureRenderer(ap); + } + + fr.transferSettings(ap. + seqPanel.seqCanvas.getFeatureRenderer()); + } + + return fr; + } + + @Override + public jalview.api.SequenceRenderer getSequenceRenderer(AlignmentViewPanel alignment) + { + return new SequenceRenderer(((AlignmentPanel)alignment).av); + } + + public void sendConsoleEcho(String strEcho) + { + if (console != null) + { + console.sendConsoleEcho(strEcho); + } + } + + public void sendConsoleMessage(String strStatus) + { + if (console != null && strStatus != null) + // && !strStatus.equals("Script completed")) + // should we squash the script completed string ? + { + console.sendConsoleMessage(strStatus); + } + } + + @Override + public void showUrl(String url, String target) + { + try + { + jalview.util.BrowserLauncher.openURL(url); + } catch (Exception e) + { + Cache.log.error("Failed to launch Jmol-associated url " + url, e); + // TODO: 2.6 : warn user if browser was not configured. + } + } + + @Override + public void refreshGUI() + { + // appJmolWindow.repaint(); + javax.swing.SwingUtilities.invokeLater(new Runnable() + { + public void run() + { + appJmolWindow.updateTitleAndMenus(); + appJmolWindow.revalidate(); + } + }); + } + + public void updateColours(Object source) + { + AlignmentPanel ap = (AlignmentPanel) source,topap; + // ignore events from unrelated or non-user interactive frames + if ((topap=appJmolWindow.getAlignmentPanelFor(ap.av.getAlignment()))==null || topap.alignFrame.getCurrentView() != ap.av || !appJmolWindow.isUsedforcolourby(ap)) + return; + if (!isLoadingFromArchive()) { + colourBySequence(ap.av.getShowSequenceFeatures(), ap); + } + } + + public void notifyScriptTermination(String strStatus, int msWalltime) + { + // todo - script termination doesn't happen ? + // if (console != null) + // console.notifyScriptTermination(strStatus, + // msWalltime); + } + + public void showUrl(String url) + { + showUrl(url, "jmol"); + } + + public void newJmolPopup(boolean translateLocale, String menuName, + boolean asPopup) + { + + jmolpopup = JmolPopup.newJmolPopup(viewer, translateLocale, menuName, + asPopup); + } + + public void selectionChanged(BitSet arg0) + { + // TODO Auto-generated method stub + + } + + public void refreshPdbEntries() + { + // TODO Auto-generated method stub + + } + + public void showConsole(boolean b) + { + appJmolWindow.showConsole(b); + } + + /** + * add the given sequences to the mapping scope for the given pdb file handle + * + * @param pdbFile + * - pdbFile identifier + * @param seq + * - set of sequences it can be mapped to + */ + public void addSequenceForStructFile(String pdbFile, SequenceI[] seq) + { + for (int pe = 0; pe < pdbentry.length; pe++) + { + if (pdbentry[pe].getFile().equals(pdbFile)) + { + addSequence(pe, seq); + } + } + } + + @Override + protected JmolAppConsoleInterface createJmolConsole(JmolViewer viewer2, + Container consolePanel, String buttonsToShow) + { + return new AppConsole(viewer, consolePanel, buttonsToShow); + } + + @Override + protected void releaseUIResources() + { + appJmolWindow = null; + if (console != null) + { + try + { + console.setVisible(false); + } catch (Error e) + { + } catch (Exception x) + { + } + ; + console = null; + } + + } + + @Override + public void releaseReferences(Object svl) + { + if (svl instanceof SeqPanel) { + appJmolWindow.removeAlignmentPanel(((SeqPanel) svl).ap); + + }; + } +}