X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fext%2Fjmol%2FJalviewJmolBinding.java;h=a314fd6cca1c4118d4a97830d6a9fbe905fc7569;hb=642c2b09a1ad285fca557ded382a5c175a943711;hp=44a999310c88df122fb358901a688fcd3d70da27;hpb=8449a33e712dfec13771d4e1b8be20bf625f190b;p=jalview.git diff --git a/src/jalview/ext/jmol/JalviewJmolBinding.java b/src/jalview/ext/jmol/JalviewJmolBinding.java index 44a9993..a314fd6 100644 --- a/src/jalview/ext/jmol/JalviewJmolBinding.java +++ b/src/jalview/ext/jmol/JalviewJmolBinding.java @@ -1,5 +1,5 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.5) + * 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. @@ -20,9 +20,12 @@ package jalview.ext.jmol; 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.FeatureRenderer; import jalview.api.SequenceRenderer; import jalview.api.SequenceStructureBinding; @@ -35,11 +38,13 @@ 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 JalviewJmolBinding implements StructureListener, - JmolStatusListener, SequenceStructureBinding, JmolSelectionListener + JmolStatusListener, SequenceStructureBinding, + JmolSelectionListener, ComponentListener { /** @@ -76,7 +81,12 @@ public abstract class JalviewJmolBinding implements StructureListener, public Vector chainNames; - String[] chains; + Hashtable chainFile; + + /** + * array of target chains for seuqences - tied to pdbentry and sequence[] + */ + protected String[][] chains; boolean colourBySequence = true; @@ -106,26 +116,32 @@ public abstract class JalviewJmolBinding implements StructureListener, public PDBEntry[] pdbentry; /** - * datasource protocol for access to PDBEntry + * datasource protocol for access to PDBEntrylatest */ String protocol = null; StringBuffer resetLastRes = new StringBuffer(); - public SequenceI[] sequence; + /** + * sequences mapped to each pdbentry + */ + public SequenceI[][] sequence; StructureSelectionManager ssm; public JmolViewer viewer; - public JalviewJmolBinding(PDBEntry[] pdbentry, SequenceI[] seq, - String[] chains, String protocol) + public JalviewJmolBinding(PDBEntry[] pdbentry, SequenceI[][] sequenceIs, + String[][] chains, String protocol) { - this.sequence = seq; + 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(), @@ -151,11 +167,13 @@ public abstract class JalviewJmolBinding implements StructureListener, public String getViewerTitle() { if (sequence == null || pdbentry == null || sequence.length < 1 - || pdbentry.length < 1) + || pdbentry.length < 1 || sequence[0].length < 1) { return ("Jalview Jmol Window"); } - StringBuffer title = new StringBuffer(sequence[0].getName() + ":" + // 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) @@ -195,8 +213,9 @@ public abstract class JalviewJmolBinding implements StructureListener, 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) + " /" - + getModelNum(lbl.substring(0, mlength)) + " or "); + + (1 + getModelNum((String) chainFile.get(lbl))) + " or "); } if (cmd.length() > 0) cmd.setLength(cmd.length() - 4); @@ -214,11 +233,21 @@ public abstract class JalviewJmolBinding implements StructureListener, 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"); } @@ -235,12 +264,59 @@ public abstract class JalviewJmolBinding implements StructureListener, */ 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) + { String[] files = getPdbFile(); + if (refStructure >= files.length) + { + System.err.println("Invalid reference structure value " + + refStructure); + refStructure = -1; + } + if (refStructure < -1) + { + refStructure = -1; + } + StringBuffer command = new StringBuffer(), selectioncom = new StringBuffer(); - StringBuffer command = new StringBuffer(); boolean matched[] = new boolean[alignment.getWidth()]; - String commonpositions[][] = new String[files.length][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]; for (int pdbfnum = 0; pdbfnum < files.length; pdbfnum++) { StructureMapping[] mapping = ssm.getMapping(files[pdbfnum]); @@ -249,60 +325,166 @@ public abstract class JalviewJmolBinding implements StructureListener, continue; int lastPos = -1; - for (int s = 0; s < sequence.length; s++) + for (int s = 0; s < sequence[pdbfnum].length; s++) { for (int sp, m = 0; m < mapping.length; m++) { - if (mapping[m].getSequence() == sequence[s] - && (sp = alignment.findIndex(sequence[s])) > -1) + 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 < asp.getLength(); r++) + for (int r = 0; r < matched.length; r++) { - // no mapping to gaps in sequence + 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))) { - matched[r] = false; // exclude from common set + // no mapping to gaps in sequence continue; } - int pos = mapping[m].getPDBResNum(asp.findPosition(r)); + 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; - - commonpositions[m][r] = (mapping[m].getChain() != " " ? ":" - + mapping[m].getChain() : "") - + "/" + (pdbfnum + 1) + ".1"; + // 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(); + } + // move on to next pdb file + s = sequence[pdbfnum].length; break; } } } } - command.append("select "); - // form the matched pair selection strings - String sep = ""; - for (int r = 0; r < matched.length; r++) + String[] selcom = new String[files.length]; + int nmatched = 0; + // generate select statements to select regions to superimpose structures { - if (matched[r]) + for (int pdbfnum = 0; pdbfnum < files.length; pdbfnum++) { - command.append(sep); - command.append("("); - for (int s = 0; s < commonpositions.length; s++) + 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 (s > 0) + if (matched[r]) { - command.append(" | "); + 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); } - command.append(commonpositions[s][r]); } - command.append(")"); - sep = " | "; + // 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("compare "); + 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()); + + // evalStateCommand("select *; backbone; select "+selcom.toString()+"; cartoons; center "+selcom.toString()); } public void evalStateCommand(String command) @@ -348,12 +530,12 @@ public abstract class JalviewJmolBinding implements StructureListener, continue; int lastPos = -1; - for (int s = 0; s < sequence.length; s++) + for (int s = 0; s < sequence[pdbfnum].length; s++) { for (int sp, m = 0; m < mapping.length; m++) { - if (mapping[m].getSequence() == sequence[s] - && (sp = alignment.findIndex(sequence[s])) > -1) + 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++) @@ -370,10 +552,10 @@ public abstract class JalviewJmolBinding implements StructureListener, lastPos = pos; - Color col = sr.getResidueBoxColour(sequence[s], r); + Color col = sr.getResidueBoxColour(sequence[pdbfnum][s], r); - if (showFeatures) - col = fr.findFeatureColour(col, sequence[s], r); + if (showFeatures && fr != null) + col = fr.findFeatureColour(col, sequence[pdbfnum][s], r); String newSelcom = (mapping[m].getChain() != " " ? ":" + mapping[m].getChain() : "") + "/" @@ -510,23 +692,49 @@ public abstract class JalviewJmolBinding implements StructureListener, 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 String[] getPdbFile() + public synchronized String[] getPdbFile() { + if (viewer == null) + { + return new String[0]; + } if (modelFileNames == null) { + String mset[] = new String[viewer.getModelCount()]; - for (int i = 0; i < mset.length; i++) + _modelFileNameMap = new int[mset.length]; + int j = 1; + mset[0] = viewer.getModelFileName(0); + for (int i = 1; i < mset.length; i++) { - mset[i] = viewer.getModelFileName(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 = mset; + modelFileNames = new String[j]; + System.arraycopy(mset, 0, modelFileNames, 0, j); } return modelFileNames; } - public Hashtable getRegistryInfo() + /** + * map from string to applet + */ + public Map getRegistryInfo() { // TODO Auto-generated method stub return null; @@ -619,6 +827,14 @@ public abstract class JalviewJmolBinding implements StructureListener, 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); } @@ -783,7 +999,6 @@ public abstract class JalviewJmolBinding implements StructureListener, case JmolConstants.CALLBACK_MEASURE: case JmolConstants.CALLBACK_CLICK: - default: System.err.println("Unhandled callback " + type + " " + data[1].toString()); @@ -818,6 +1033,16 @@ public abstract class JalviewJmolBinding implements StructureListener, 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) { @@ -827,6 +1052,9 @@ public abstract class JalviewJmolBinding implements StructureListener, 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. @@ -834,6 +1062,7 @@ public abstract class JalviewJmolBinding implements StructureListener, String[] oldmodels = modelFileNames; modelFileNames = null; chainNames = new Vector(); + chainFile = new Hashtable(); boolean notifyLoaded = false; String[] modelfilenames = getPdbFile(); ssm = StructureSelectionManager.getStructureSelectionManager(); @@ -876,84 +1105,103 @@ public abstract class JalviewJmolBinding implements StructureListener, for (int modelnum = 0; modelnum < modelfilenames.length; modelnum++) { String fileName = modelfilenames[modelnum]; - if (fileName != null) + 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) { - boolean foundEntry = false; - // search pdbentries and sequences to find correct pdbentry and - // sequence[] pair for this filename - if (pdbentry != null) + // search pdbentries and sequences to find correct pdbentry for this + // model + for (int pe = 0; pe < pdbentry.length; pe++) { - for (int pe = 0; pe < pdbentry.length; pe++) + boolean matches = false; + if (fileName == null) { - if (pdbentry[pe].getFile().equals(fileName)) + 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; - MCview.PDBfile pdb; - if (loadedInline) - { - // TODO: replace with getData ? - pdb = ssm.setMapping(sequence, chains, - pdbentry[pe].getFile(), AppletFormatAdapter.PASTE); - pdbentry[pe].setFile("INLINE" + pdb.id); - } - else + } + } + 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 { - // 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) + File fl = new java.io.File(pdbentry[pe].getFile()); + if (fl.exists()) { + protocol = AppletFormatAdapter.FILE; } - ; - pdb = ssm.setMapping(sequence, chains, - pdbentry[pe].getFile(), protocol); - - } - - pdbentry[pe].setId(pdb.id); - - for (int i = 0; i < pdb.chains.size(); i++) + } catch (Exception e) + { + } catch (Error e) { - chainNames.addElement(new String(pdb.id + ":" - + ((MCview.PDBChain) pdb.chains.elementAt(i)).id)); } - notifyLoaded = true; + ; + 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; + } + 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) { - jmolpopup.updateComputedMenus(); + // potential for deadlock here: + // jmolpopup.updateComputedMenus(); } if (!isLoadingFromArchive()) { @@ -971,6 +1219,7 @@ public abstract class JalviewJmolBinding implements StructureListener, fr.featuresAdded(); } refreshGUI(); + loadNotifiesHandled++; } } @@ -1062,13 +1311,88 @@ public abstract class JalviewJmolBinding implements StructureListener, */ public abstract void refreshGUI(); - public void allocateViewer(Component renderPanel, String htmlName, - URL documentBase, URL codeBase, String commandOptions) + /** + * 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) { viewer = JmolViewer.allocateViewer(renderPanel, - new SmarterJmolAdapter(), - htmlName + ((Object) this).toString(), documentBase, codeBase, + (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) @@ -1088,4 +1412,142 @@ public abstract class JalviewJmolBinding implements StructureListener, + 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; + } + } }