X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fext%2Frbvi%2Fchimera%2FJalviewChimeraBinding.java;fp=src%2Fjalview%2Fext%2Frbvi%2Fchimera%2FJalviewChimeraBinding.java;h=7e72d8f7238abb0f4a3b9d8d87b778c180f57cde;hb=ae216fceddd8539d20fa5425cdaef3da73aba8f0;hp=0000000000000000000000000000000000000000;hpb=c836ef4e5b9782513f635d9ac2d800a98c3da779;p=jalview.git diff --git a/src/jalview/ext/rbvi/chimera/JalviewChimeraBinding.java b/src/jalview/ext/rbvi/chimera/JalviewChimeraBinding.java new file mode 100644 index 0000000..7e72d8f --- /dev/null +++ b/src/jalview/ext/rbvi/chimera/JalviewChimeraBinding.java @@ -0,0 +1,1446 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2) + * Copyright (C) 2014 The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ +package jalview.ext.rbvi.chimera; + +import static org.junit.Assert.assertTrue; +import jalview.api.AlignmentViewPanel; +import jalview.api.FeatureRenderer; +import jalview.api.SequenceRenderer; +import jalview.api.SequenceStructureBinding; +import jalview.api.StructureSelectionManagerProvider; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.ColumnSelection; +import jalview.datamodel.PDBEntry; +import jalview.datamodel.SequenceI; +import jalview.io.AppletFormatAdapter; +import jalview.schemes.ColourSchemeI; +import jalview.schemes.ResidueProperties; +import jalview.structure.StructureListener; +import jalview.structure.StructureMapping; +import jalview.structure.StructureSelectionManager; +import jalview.structures.models.SequenceStructureBindingModel; + +import java.awt.Color; +import java.awt.Container; +import java.awt.event.ComponentEvent; +import java.awt.event.ComponentListener; +import java.io.File; +import java.net.URL; +import java.security.AccessControlException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Hashtable; +import java.util.List; +import java.util.Map; +import java.util.Vector; + +import org.jmol.adapter.smarter.SmarterJmolAdapter; +import org.jmol.api.JmolAppConsoleInterface; +import org.jmol.api.JmolSelectionListener; +import org.jmol.api.JmolStatusListener; +import org.jmol.api.JmolViewer; +import org.jmol.constant.EnumCallback; +import org.jmol.popup.JmolPopup; + +import ext.edu.ucsf.rbvi.strucviz2.ChimeraManager; +import ext.edu.ucsf.rbvi.strucviz2.ChimeraModel; +import ext.edu.ucsf.rbvi.strucviz2.StructureManager; +import ext.edu.ucsf.rbvi.strucviz2.StructureManager.ModelType; +import sun.rmi.runtime.Log; + +public abstract class JalviewChimeraBinding extends + SequenceStructureBindingModel implements StructureListener, + SequenceStructureBinding, StructureSelectionManagerProvider + +{ + private StructureManager csm; + + private ChimeraManager viewer; + + /** + * set if chimera 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; + + /** + * second flag to indicate if the jmol viewer should ignore sequence colouring + * events from the structure manager because the GUI is still setting up + */ + private boolean loadingFinished = true; + + /** + * 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; + + private Map> chimmaps = new HashMap>(); + + private List mdlToFile = new ArrayList(); + + /** + * the default or current model displayed if the model cannot be identified + * from the selection message + */ + int frameNo = 0; + + String lastCommand; + + String lastMessage; + + boolean loadedInline; + + public boolean openFile(PDBEntry pe) + { + String file = pe.getFile(); + try + { + List oldList = viewer.getModelList(); + viewer.openModel(file, ModelType.PDB_MODEL); + List newList = viewer.getModelList(); + if (oldList.size() < newList.size()) + { + while (oldList.size() > 0) + { + oldList.remove(0); + newList.remove(0); + } + chimmaps.put(file, newList); + for (ChimeraModel cm : newList) + { + while (mdlToFile.size()<1+cm.getModelNumber()) + { + mdlToFile.add(new String("")); + } + mdlToFile.set(cm.getModelNumber(), file); + } + + File fl = new File(file); + String protocol = AppletFormatAdapter.URL; + try + { + if (fl.exists()) + { + protocol = AppletFormatAdapter.FILE; + } + } catch (Exception e) + { + } catch (Error e) + { + } + // Explicitly map to the filename used by Jmol ; + // pdbentry[pe].getFile(), protocol); + + if (ssm != null) + { + ssm.addStructureViewerListener(this); + // ssm.addSelectionListener(this); + FeatureRenderer fr = getFeatureRenderer(null); + if (fr != null) + { + fr.featuresAdded(); + } + refreshGUI(); + } + return true; + } + } catch (Exception q) + { + log("Exception when trying to open model " + file + "\n" + + q.toString()); + q.printStackTrace(); + } + return false; + } + + /** + * current set of model filenames loaded + */ + 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; + + private List lastReply; + + public JalviewChimeraBinding(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 = new ChimeraManager( + csm = new ext.edu.ucsf.rbvi.strucviz2.StructureManager(true)); + /* + * viewer = JmolViewer.allocateViewer(renderPanel, new SmarterJmolAdapter(), + * "jalviewJmol", ap.av.applet .getDocumentBase(), + * ap.av.applet.getCodeBase(), "", this); + * + * jmolpopup = JmolPopup.newJmolPopup(viewer, true, "Jmol", true); + */ + } + + public JalviewChimeraBinding(StructureSelectionManager ssm, + ChimeraManager viewer2) + { + this.ssm = ssm; + viewer = viewer2; + csm = viewer.getStructureManager(); + } + + /** + * 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 Chimera Window"); + } + // TODO: give a more informative title when multiple structures are + // displayed. + StringBuffer title = new StringBuffer("Chimera view for " + + 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("#" + getModelNum((String) chainFile.get(lbl)) + "." + + lbl.substring(mlength + 1) + " or "); + } + if (cmd.length() > 0) + cmd.setLength(cmd.length() - 4); + evalStateCommand("~display #*; ~ribbon #*; ribbon " + cmd + ";focus " + + cmd); + } + + public void closeViewer() + { + ssm.removeStructureViewerListener(this, this.getPdbFile()); + // and shut down Chimera + viewer.exitChimera(); + // 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("colour *;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) + { + assert (_alignment.length == _refStructure.length && _alignment.length != _hiddenCols.length); + + String[] files = getPdbFile(); + // check to see if we are still waiting for Jmol files + long starttime = System.currentTimeMillis(); + boolean waiting = true; + do + { + waiting = false; + for (String file : files) + { + try + { + // HACK - in Jalview 2.8 this call may not be threadsafe so we catch + // every possible exception + StructureMapping[] sm = ssm.getMapping(file); + if (sm == null || sm.length == 0) + { + waiting = true; + } + } catch (Exception x) + { + waiting = true; + } catch (Error q) + { + waiting = true; + } + } + // we wait around for a reasonable time before we give up + } while (waiting + && System.currentTimeMillis() < (10000 + 1000 * files.length + starttime)); + if (waiting) + { + System.err + .println("RUNTIME PROBLEM: Jmol seems to be taking a long time to process all the structures."); + return; + } + StringBuffer selectioncom = new StringBuffer(); + // In principle - nSeconds specifies the speed of animation for each + // superposition - but is seems to behave weirdly, so we don't specify it. + String nSeconds = " "; + if (files.length > 10) + { + nSeconds = " 0.00001 "; + } + else + { + nSeconds = " " + (2.0 / files.length) + " "; + // if (nSeconds).substring(0,5)+" "; + } + // see JAL-1345 - should really automatically turn off the animation for + // large numbers of structures, but Jmol doesn't seem to allow that. + nSeconds = " "; + // 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]); + // RACE CONDITION - getMapping only returns Jmol loaded filenames once + // Jmol callback has completed. + if (mapping == null || mapping.length < 1) + { + throw new Error( + "Implementation error - Jmol seems to be still working on getting its data - report at http://issues.jalview.org/browse/JAL-1016"); + } + 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; + } + } + } + } + + // TODO: consider bailing if nmatched less than 4 because superposition + // not + // well defined. + // TODO: refactor superposable position search (above) from jmol selection + // construction (below) + + 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("}"); + } + if (molsel.length() > 1) + { + 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("|"); + } + } + else + { + selcom[pdbfnum] = null; + } + } + } + for (int pdbfnum = 0; pdbfnum < files.length; pdbfnum++) + { + if (pdbfnum == refStructure || selcom[pdbfnum] == null + || selcom[refStructure] == null) + { + continue; + } + command.append("echo "); + command.append("\"Superposing ("); + command.append(chainNames[pdbfnum]); + command.append(") against reference ("); + command.append(chainNames[refStructure]); + command.append(")\";\ncompare " + nSeconds); + 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"); + } + if (selectioncom.length() > 0) + { + 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()); + } + } + + private void checkLaunched() + { + if (!viewer.isChimeraLaunched()) + { + viewer.launchChimera(csm.getChimeraPaths()); + } + if (!viewer.isChimeraLaunched()) + { + log("Failed to launch Chimera!"); + } + } + + public void evalStateCommand(String command) + { + viewerCommandHistory(false); + checkLaunched(); + if (lastCommand == null || !lastCommand.equals(command)) + { + + lastReply = viewer.sendChimeraCommand(command, true); + if (debug) + { + log("Response from command ('" + command + "') was:\n" + lastReply); + } + } + viewerCommandHistory(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 || !loadingFinished) + 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 (jalview.structure.StructureMappingcommandSet cpdbbyseq : ChimeraCommands + .getColourBySequenceCommand(ssm, files, sequence, sr, fr, + alignment)) + for (String cbyseq : cpdbbyseq.commands) + { + 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; + log("get model / residue colour attribute unimplemented"); + return null; + } + + /** + * 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) +// { +// Collection chimodels = viewer.getChimeraModels(); +// _modelFileNameMap = new int[chimodels.size()]; +// int j = 0; +// for (ChimeraModel chimodel : chimodels) +// { +// String mdlName = chimodel.getModelName(); +// } +// modelFileNames = new String[j]; +// // System.arraycopy(mset, 0, modelFileNames, 0, j); +// } + + return chimmaps.keySet().toArray( + modelFileNames = new String[chimmaps.size()]); + } + + /** + * 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); + + // jmol/ssm only + public void highlightAtom(int atomIndex, int pdbResNum, String chain, + String pdbfile) + { + List cms = chimmaps.get(pdbfile); + if (cms != null) + { + int mdlNum = cms.get(0).getModelNumber(); + + viewerCommandHistory(false); + viewer.stopListening(); + if (resetLastRes.length() > 0) + { + viewer.sendChimeraCommand(resetLastRes.toString(), false); + } + + eval.setLength(0); + eval.append("display "); // +modelNum + + resetLastRes.setLength(0); + resetLastRes.append("~display "); + { + eval.append(" #" + (mdlNum)); + resetLastRes.append("#" + (mdlNum)); + } + // complete select string + + eval.append(":" + pdbResNum); + resetLastRes.append(":" + pdbResNum); + if (!chain.equals(" ")) + { + eval.append("." + chain); + resetLastRes.append("." + chain); + } + eval.append(eval.toString()); + + resetLastRes.append(resetLastRes.toString() + ); + + viewer.sendChimeraCommand(eval.toString(), false); + viewerCommandHistory(true); + viewer.startListening(); + } + } + + boolean debug = true; + + private void log(String message) + { + System.err.println("## Chimera log: " + message); + } + + private void viewerCommandHistory(boolean enable) + { + log("(Not yet implemented) 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); + log("cannot load inline in Chimera, yet"); + } + + public void mouseOverStructure(int atomIndex, String strInfo) + { + // function to parse a mouseOver event from Chimera + // + 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. + int _mp = _modelFileNameMap.length - 1, mnumber = new Integer(mdlId) + .intValue() - 1; + while (mnumber < _modelFileNameMap[_mp]) + { + _mp--; + } + pdbfilename = modelFileNames[_mp]; + if (pdbfilename == null) + { + // pdbfilename = new File(viewer.getModelFileName(mnumber)) + // .getAbsolutePath(); + } + + } catch (Exception e) + { + } + ; + } + if (lastMessage == null || !lastMessage.equals(strInfo)) + ssm.mouseOverStructure(pdbResNum, chainId, pdbfilename); + + lastMessage = strInfo; + } + + 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); + } + // rewrite these selections for chimera (DNA, RNA and protein) + 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 + "))"; + viewerCommandHistory(false); + + if (!atomsPicked.contains(picked)) + { + viewer.select(picked); + atomsPicked.addElement(picked); + } + else + { + viewer.select("not " + picked); + atomsPicked.removeElement(picked); + } + viewerCommandHistory(true); + // TODO: in application this happens + // + // if (scriptWindow != null) + // { + // scriptWindow.sendConsoleMessage(strInfo); + // scriptWindow.sendConsoleMessage("\n"); + // } + + } + + // 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); + } + } + + // 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 setJalviewColourScheme(ColourSchemeI cs) + { + colourBySequence = false; + + if (cs == null) + return; + + String res; + int index; + Color col; + viewerCommandHistory(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)); + // TODO: need colour string function and res selection here + command.append("select " + res + ";color[" + col.getRed() + "," + + col.getGreen() + "," + col.getBlue() + "];"); + } + + evalStateCommand(command.toString()); + viewerCommandHistory(true); + } + + public void showHelp() + { + // chimera help + 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(); + + public void componentResized(ComponentEvent e) + { + + } + + public void componentMoved(ComponentEvent e) + { + + } + + public void componentShown(ComponentEvent e) + { + } + + public void componentHidden(ComponentEvent e) + { + } + + public void setLoadingFromArchive(boolean loadingFromArchive) + { + this.loadingFromArchive = loadingFromArchive; + } + + /** + * + * @return true if Jmol is still restoring state or loading is still going on + * (see setFinsihedLoadingFromArchive) + */ + public boolean isLoadingFromArchive() + { + return loadingFromArchive && !loadingFinished; + } + + /** + * modify flag which controls if sequence colouring events are honoured by the + * binding. Should be true for normal operation + * + * @param finishedLoading + */ + public void setFinishedLoadingFromArchive(boolean finishedLoading) + { + loadingFinished = finishedLoading; + } + + public void setBackgroundColour(java.awt.Color col) + { + viewerCommandHistory(false); + // todo set background colour + viewer.sendChimeraCommand( + "background [" + col.getRed() + "," + col.getGreen() + "," + + col.getBlue() + "];", false); + viewerCommandHistory(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); + } + +}