src/jalview/structure/StructureSelectionManager.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.structure;
  22
  23 import jalview.analysis.AlignSeq;
  24 import jalview.api.StructureSelectionManagerProvider;
  25 import jalview.commands.CommandI;
  26 import jalview.commands.EditCommand;
  27 import jalview.commands.OrderCommand;
  28 import jalview.datamodel.AlignedCodonFrame;
  29 import jalview.datamodel.AlignmentAnnotation;
  30 import jalview.datamodel.AlignmentI;
  31 import jalview.datamodel.Annotation;
  32 import jalview.datamodel.PDBEntry;
  33 import jalview.datamodel.SearchResults;
  34 import jalview.datamodel.SearchResultsI;
  35 import jalview.datamodel.SequenceI;
  36 import jalview.ext.jmol.JmolParser;
  37 import jalview.gui.IProgressIndicator;
  38 import jalview.io.AppletFormatAdapter;
  39 import jalview.io.DataSourceType;
  40 import jalview.io.StructureFile;
  41 import jalview.util.MappingUtils;
  42 import jalview.util.MessageManager;
  43 import jalview.ws.sifts.SiftsClient;
  44 import jalview.ws.sifts.SiftsException;
  45 import jalview.ws.sifts.SiftsSettings;
  46
  47 import java.io.PrintStream;
  48 import java.util.ArrayList;
  49 import java.util.Arrays;
  50 import java.util.Collections;
  51 import java.util.Enumeration;
  52 import java.util.HashMap;
  53 import java.util.IdentityHashMap;
  54 import java.util.List;
  55 import java.util.Map;
  56 import java.util.Vector;
  57
  58 import MCview.Atom;
  59 import MCview.PDBChain;
  60 import MCview.PDBfile;
  61
  62 public class StructureSelectionManager
  63 {
  64   public final static String NEWLINE = System.lineSeparator();
  65
  66   static IdentityHashMap<StructureSelectionManagerProvider, StructureSelectionManager> instances;
  67
  68   private List<StructureMapping> mappings = new ArrayList<StructureMapping>();
  69
  70   private boolean processSecondaryStructure = false;
  71
  72   private boolean secStructServices = false;
  73
  74   private boolean addTempFacAnnot = false;
  75
  76   private IProgressIndicator progressIndicator;
  77
  78   private SiftsClient siftsClient = null;
  79
  80   private long progressSessionId;
  81
  82   /*
  83    * Set of any registered mappings between (dataset) sequences.
  84    */
  85   private List<AlignedCodonFrame> seqmappings = new ArrayList<AlignedCodonFrame>();
  86
  87   private List<CommandListener> commandListeners = new ArrayList<CommandListener>();
  88
  89   private List<SelectionListener> sel_listeners = new ArrayList<SelectionListener>();
  90
  91   /**
  92    * @return true if will try to use external services for processing secondary
  93    *         structure
  94    */
  95   public boolean isSecStructServices()
  96   {
  97     return secStructServices;
  98   }
  99
 100   /**
 101    * control use of external services for processing secondary structure
 102    *
 103    * @param secStructServices
 104    */
 105   public void setSecStructServices(boolean secStructServices)
 106   {
 107     this.secStructServices = secStructServices;
 108   }
 109
 110   /**
 111    * flag controlling addition of any kind of structural annotation
 112    *
 113    * @return true if temperature factor annotation will be added
 114    */
 115   public boolean isAddTempFacAnnot()
 116   {
 117     return addTempFacAnnot;
 118   }
 119
 120   /**
 121    * set flag controlling addition of structural annotation
 122    *
 123    * @param addTempFacAnnot
 124    */
 125   public void setAddTempFacAnnot(boolean addTempFacAnnot)
 126   {
 127     this.addTempFacAnnot = addTempFacAnnot;
 128   }
 129
 130   /**
 131    *
 132    * @return if true, the structure manager will attempt to add secondary
 133    *         structure lines for unannotated sequences
 134    */
 135
 136   public boolean isProcessSecondaryStructure()
 137   {
 138     return processSecondaryStructure;
 139   }
 140
 141   /**
 142    * Control whether structure manager will try to annotate mapped sequences
 143    * with secondary structure from PDB data.
 144    *
 145    * @param enable
 146    */
 147   public void setProcessSecondaryStructure(boolean enable)
 148   {
 149     processSecondaryStructure = enable;
 150   }
 151
 152   /**
 153    * debug function - write all mappings to stdout
 154    */
 155   public void reportMapping()
 156   {
 157     if (mappings.isEmpty())
 158     {
 159       System.err.println("reportMapping: No PDB/Sequence mappings.");
 160     }
 161     else
 162     {
 163       System.err.println("reportMapping: There are " + mappings.size()
 164               + " mappings.");
 165       int i = 0;
 166       for (StructureMapping sm : mappings)
 167       {
 168         System.err.println("mapping " + i++ + " : " + sm.pdbfile);
 169       }
 170     }
 171   }
 172
 173   /**
 174    * map between the PDB IDs (or structure identifiers) used by Jalview and the
 175    * absolute filenames for PDB data that corresponds to it
 176    */
 177   Map<String, String> pdbIdFileName = new HashMap<String, String>();
 178
 179   Map<String, String> pdbFileNameId = new HashMap<String, String>();
 180
 181   public void registerPDBFile(String idForFile, String absoluteFile)
 182   {
 183     pdbIdFileName.put(idForFile, absoluteFile);
 184     pdbFileNameId.put(absoluteFile, idForFile);
 185   }
 186
 187   public String findIdForPDBFile(String idOrFile)
 188   {
 189     String id = pdbFileNameId.get(idOrFile);
 190     return id;
 191   }
 192
 193   public String findFileForPDBId(String idOrFile)
 194   {
 195     String id = pdbIdFileName.get(idOrFile);
 196     return id;
 197   }
 198
 199   public boolean isPDBFileRegistered(String idOrFile)
 200   {
 201     return pdbFileNameId.containsKey(idOrFile)
 202             || pdbIdFileName.containsKey(idOrFile);
 203   }
 204
 205   private static StructureSelectionManager nullProvider = null;
 206
 207   public static StructureSelectionManager getStructureSelectionManager(
 208           StructureSelectionManagerProvider context)
 209   {
 210     if (context == null)
 211     {
 212       if (nullProvider == null)
 213       {
 214         if (instances != null)
 215         {
 216           throw new Error(
 217                   MessageManager
 218                           .getString("error.implementation_error_structure_selection_manager_null"),
 219                   new NullPointerException(MessageManager
 220                           .getString("exception.ssm_context_is_null")));
 221         }
 222         else
 223         {
 224           nullProvider = new StructureSelectionManager();
 225         }
 226         return nullProvider;
 227       }
 228     }
 229     if (instances == null)
 230     {
 231       instances = new java.util.IdentityHashMap<StructureSelectionManagerProvider, StructureSelectionManager>();
 232     }
 233     StructureSelectionManager instance = instances.get(context);
 234     if (instance == null)
 235     {
 236       if (nullProvider != null)
 237       {
 238         instance = nullProvider;
 239       }
 240       else
 241       {
 242         instance = new StructureSelectionManager();
 243       }
 244       instances.put(context, instance);
 245     }
 246     return instance;
 247   }
 248
 249   /**
 250    * flag controlling whether SeqMappings are relayed from received sequence
 251    * mouse over events to other sequences
 252    */
 253   boolean relaySeqMappings = true;
 254
 255   /**
 256    * Enable or disable relay of seqMapping events to other sequences. You might
 257    * want to do this if there are many sequence mappings and the host computer
 258    * is slow
 259    *
 260    * @param relay
 261    */
 262   public void setRelaySeqMappings(boolean relay)
 263   {
 264     relaySeqMappings = relay;
 265   }
 266
 267   /**
 268    * get the state of the relay seqMappings flag.
 269    *
 270    * @return true if sequence mouse overs are being relayed to other mapped
 271    *         sequences
 272    */
 273   public boolean isRelaySeqMappingsEnabled()
 274   {
 275     return relaySeqMappings;
 276   }
 277
 278   Vector listeners = new Vector();
 279
 280   /**
 281    * register a listener for alignment sequence mouseover events
 282    *
 283    * @param svl
 284    */
 285   public void addStructureViewerListener(Object svl)
 286   {
 287     if (!listeners.contains(svl))
 288     {
 289       listeners.addElement(svl);
 290     }
 291   }
 292
 293   /**
 294    * Returns the file name for a mapped PDB id (or null if not mapped).
 295    *
 296    * @param pdbid
 297    * @return
 298    */
 299   public String alreadyMappedToFile(String pdbid)
 300   {
 301     for (StructureMapping sm : mappings)
 302     {
 303       if (sm.getPdbId().equals(pdbid))
 304       {
 305         return sm.pdbfile;
 306       }
 307     }
 308     return null;
 309   }
 310
 311   /**
 312    * Import structure data and register a structure mapping for broadcasting
 313    * colouring, mouseovers and selection events (convenience wrapper).
 314    *
 315    * @param sequence
 316    *          - one or more sequences to be mapped to pdbFile
 317    * @param targetChains
 318    *          - optional chain specification for mapping each sequence to pdb
 319    *          (may be nill, individual elements may be nill)
 320    * @param pdbFile
 321    *          - structure data resource
 322    * @param protocol
 323    *          - how to resolve data from resource
 324    * @return null or the structure data parsed as a pdb file
 325    */
 326   synchronized public StructureFile setMapping(SequenceI[] sequence,
 327           String[] targetChains, String pdbFile, DataSourceType protocol)
 328   {
 329     return setMapping(true, sequence, targetChains, pdbFile, protocol);
 330   }
 331
 332   /**
 333    * create sequence structure mappings between each sequence and the given
 334    * pdbFile (retrieved via the given protocol).
 335    *
 336    * @param forStructureView
 337    *          when true, record the mapping for use in mouseOvers
 338    *
 339    * @param sequenceArray
 340    *          - one or more sequences to be mapped to pdbFile
 341    * @param targetChainIds
 342    *          - optional chain specification for mapping each sequence to pdb
 343    *          (may be nill, individual elements may be nill)
 344    * @param pdbFile
 345    *          - structure data resource
 346    * @param sourceType
 347    *          - how to resolve data from resource
 348    * @return null or the structure data parsed as a pdb file
 349    */
 350   synchronized public StructureFile setMapping(boolean forStructureView,
 351           SequenceI[] sequenceArray, String[] targetChainIds,
 352           String pdbFile, DataSourceType sourceType)
 353   {
 354     /*
 355      * There will be better ways of doing this in the future, for now we'll use
 356      * the tried and tested MCview pdb mapping
 357      */
 358     boolean parseSecStr = processSecondaryStructure;
 359     if (isPDBFileRegistered(pdbFile))
 360     {
 361       for (SequenceI sq : sequenceArray)
 362       {
 363         SequenceI ds = sq;
 364         while (ds.getDatasetSequence() != null)
 365         {
 366           ds = ds.getDatasetSequence();
 367         }
 368         ;
 369         if (ds.getAnnotation() != null)
 370         {
 371           for (AlignmentAnnotation ala : ds.getAnnotation())
 372           {
 373             // false if any annotation present from this structure
 374             // JBPNote this fails for jmol/chimera view because the *file* is
 375             // passed, not the structure data ID -
 376             if (PDBfile.isCalcIdForFile(ala, findIdForPDBFile(pdbFile)))
 377             {
 378               parseSecStr = false;
 379             }
 380           }
 381         }
 382       }
 383     }
 384     StructureFile pdb = null;
 385     boolean isMapUsingSIFTs = SiftsSettings.isMapWithSifts();
 386     try
 387     {
 388       sourceType = AppletFormatAdapter.checkProtocol(pdbFile);
 389       pdb = new JmolParser(pdbFile, sourceType);
 390
 391       if (pdb.getId() != null && pdb.getId().trim().length() > 0
 392               && DataSourceType.FILE == sourceType)
 393       {
 394         registerPDBFile(pdb.getId().trim(), pdbFile);
 395       }
 396       // if PDBId is unavailable then skip SIFTS mapping execution path
 397       isMapUsingSIFTs = isMapUsingSIFTs && pdb.isPPDBIdAvailable();
 398
 399     } catch (Exception ex)
 400     {
 401       ex.printStackTrace();
 402       return null;
 403     }
 404
 405     try
 406     {
 407       if (isMapUsingSIFTs)
 408       {
 409         siftsClient = new SiftsClient(pdb);
 410       }
 411     } catch (SiftsException e)
 412     {
 413       isMapUsingSIFTs = false;
 414       e.printStackTrace();
 415     }
 416
 417     String targetChainId;
 418     for (int s = 0; s < sequenceArray.length; s++)
 419     {
 420       boolean infChain = true;
 421       final SequenceI seq = sequenceArray[s];
 422       SequenceI ds = seq;
 423       while (ds.getDatasetSequence() != null)
 424       {
 425         ds = ds.getDatasetSequence();
 426       }
 427
 428       if (targetChainIds != null && targetChainIds[s] != null)
 429       {
 430         infChain = false;
 431         targetChainId = targetChainIds[s];
 432       }
 433       else if (seq.getName().indexOf("|") > -1)
 434       {
 435         targetChainId = seq.getName().substring(
 436                 seq.getName().lastIndexOf("|") + 1);
 437         if (targetChainId.length() > 1)
 438         {
 439           if (targetChainId.trim().length() == 0)
 440           {
 441             targetChainId = " ";
 442           }
 443           else
 444           {
 445             // not a valid chain identifier
 446             targetChainId = "";
 447           }
 448         }
 449       }
 450       else
 451       {
 452         targetChainId = "";
 453       }
 454
 455       /*
 456        * Attempt pairwise alignment of the sequence with each chain in the PDB,
 457        * and remember the highest scoring chain
 458        */
 459       float max = -10;
 460       AlignSeq maxAlignseq = null;
 461       String maxChainId = " ";
 462       PDBChain maxChain = null;
 463       boolean first = true;
 464       for (PDBChain chain : pdb.getChains())
 465       {
 466         if (targetChainId.length() > 0 && !targetChainId.equals(chain.id)
 467                 && !infChain)
 468         {
 469           continue; // don't try to map chains don't match.
 470         }
 471         // TODO: correctly determine sequence type for mixed na/peptide
 472         // structures
 473         final String type = chain.isNa ? AlignSeq.DNA : AlignSeq.PEP;
 474         AlignSeq as = AlignSeq.doGlobalNWAlignment(seq, chain.sequence,
 475                 type);
 476         // equivalent to:
 477         // AlignSeq as = new AlignSeq(sequence[s], chain.sequence, type);
 478         // as.calcScoreMatrix();
 479         // as.traceAlignment();
 480
 481         if (first || as.maxscore > max
 482                 || (as.maxscore == max && chain.id.equals(targetChainId)))
 483         {
 484           first = false;
 485           maxChain = chain;
 486           max = as.maxscore;
 487           maxAlignseq = as;
 488           maxChainId = chain.id;
 489         }
 490       }
 491       if (maxChain == null)
 492       {
 493         continue;
 494       }
 495
 496       if (sourceType == DataSourceType.PASTE)
 497       {
 498         pdbFile = "INLINE" + pdb.getId();
 499       }
 500
 501       List<StructureMapping> seqToStrucMapping = new ArrayList<StructureMapping>();
 502       if (isMapUsingSIFTs && seq.isProtein())
 503       {
 504         setProgressBar(null);
 505         setProgressBar(MessageManager
 506                 .getString("status.obtaining_mapping_with_sifts"));
 507         jalview.datamodel.Mapping sqmpping = maxAlignseq
 508                 .getMappingFromS1(false);
 509         if (targetChainId != null && !targetChainId.trim().isEmpty())
 510         {
 511           StructureMapping siftsMapping;
 512           try
 513           {
 514             siftsMapping = getStructureMapping(seq, pdbFile, targetChainId,
 515                     pdb, maxChain, sqmpping, maxAlignseq);
 516             seqToStrucMapping.add(siftsMapping);
 517             maxChain.makeExactMapping(maxAlignseq, seq);
 518             maxChain.transferRESNUMFeatures(seq, null);// FIXME: is this
 519                                                        // "IEA:SIFTS" ?
 520             maxChain.transferResidueAnnotation(siftsMapping, sqmpping);
 521             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 522
 523           } catch (SiftsException e)
 524           {
 525             // fall back to NW alignment
 526             System.err.println(e.getMessage());
 527             StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 528                     targetChainId, maxChain, pdb, maxAlignseq);
 529             seqToStrucMapping.add(nwMapping);
 530             maxChain.makeExactMapping(maxAlignseq, seq);
 531             maxChain.transferRESNUMFeatures(seq, null); // FIXME: is this
 532                                                         // "IEA:Jalview" ?
 533             maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 534             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 535           }
 536         }
 537         else
 538         {
 539           List<StructureMapping> foundSiftsMappings = new ArrayList<StructureMapping>();
 540           for (PDBChain chain : pdb.getChains())
 541           {
 542             try
 543             {
 544               StructureMapping siftsMapping = getStructureMapping(seq,
 545                       pdbFile, chain.id, pdb, chain, sqmpping, maxAlignseq);
 546               foundSiftsMappings.add(siftsMapping);
 547             } catch (SiftsException e)
 548             {
 549               System.err.println(e.getMessage());
 550             }
 551           }
 552           if (!foundSiftsMappings.isEmpty())
 553           {
 554             seqToStrucMapping.addAll(foundSiftsMappings);
 555             maxChain.makeExactMapping(maxAlignseq, seq);
 556             maxChain.transferRESNUMFeatures(seq, null);// FIXME: is this
 557                                                        // "IEA:SIFTS" ?
 558             maxChain.transferResidueAnnotation(foundSiftsMappings.get(0),
 559                     sqmpping);
 560             ds.addPDBId(sqmpping.getTo().getAllPDBEntries().get(0));
 561           }
 562           else
 563           {
 564             StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 565                     maxChainId, maxChain, pdb, maxAlignseq);
 566             seqToStrucMapping.add(nwMapping);
 567             maxChain.transferRESNUMFeatures(seq, null); // FIXME: is this
 568                                                         // "IEA:Jalview" ?
 569             maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 570             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 571           }
 572         }
 573       }
 574       else
 575       {
 576         setProgressBar(null);
 577         setProgressBar(MessageManager
 578                 .getString("status.obtaining_mapping_with_nw_alignment"));
 579         StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 580                 maxChainId, maxChain, pdb, maxAlignseq);
 581         seqToStrucMapping.add(nwMapping);
 582         ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 583
 584       }
 585
 586       if (forStructureView)
 587       {
 588         mappings.addAll(seqToStrucMapping);
 589       }
 590     }
 591     return pdb;
 592   }
 593
 594   public void addStructureMapping(StructureMapping sm)
 595   {
 596     mappings.add(sm);
 597   }
 598
 599   /**
 600    * retrieve a mapping for seq from SIFTs using associated DBRefEntry for
 601    * uniprot or PDB
 602    *
 603    * @param seq
 604    * @param pdbFile
 605    * @param targetChainId
 606    * @param pdb
 607    * @param maxChain
 608    * @param sqmpping
 609    * @param maxAlignseq
 610    * @return
 611    * @throws SiftsException
 612    */
 613   private StructureMapping getStructureMapping(SequenceI seq,
 614           String pdbFile, String targetChainId, StructureFile pdb,
 615           PDBChain maxChain, jalview.datamodel.Mapping sqmpping,
 616           AlignSeq maxAlignseq) throws SiftsException
 617   {
 618     StructureMapping curChainMapping = siftsClient
 619             .getSiftsStructureMapping(seq, pdbFile, targetChainId);
 620     try
 621     {
 622       PDBChain chain = pdb.findChain(targetChainId);
 623       if (chain != null)
 624       {
 625         chain.transferResidueAnnotation(curChainMapping, sqmpping);
 626       }
 627     } catch (Exception e)
 628     {
 629       e.printStackTrace();
 630     }
 631     return curChainMapping;
 632   }
 633
 634   private StructureMapping getNWMappings(SequenceI seq, String pdbFile,
 635           String maxChainId, PDBChain maxChain, StructureFile pdb,
 636           AlignSeq maxAlignseq)
 637   {
 638     final StringBuilder mappingDetails = new StringBuilder(128);
 639     mappingDetails.append(NEWLINE).append(
 640             "Sequence \u27f7 Structure mapping details");
 641     mappingDetails.append(NEWLINE);
 642     mappingDetails
 643             .append("Method: inferred with Needleman & Wunsch alignment");
 644     mappingDetails.append(NEWLINE).append("PDB Sequence is :")
 645             .append(NEWLINE).append("Sequence = ")
 646             .append(maxChain.sequence.getSequenceAsString());
 647     mappingDetails.append(NEWLINE).append("No of residues = ")
 648             .append(maxChain.residues.size()).append(NEWLINE)
 649             .append(NEWLINE);
 650     PrintStream ps = new PrintStream(System.out)
 651     {
 652       @Override
 653       public void print(String x)
 654       {
 655         mappingDetails.append(x);
 656       }
 657
 658       @Override
 659       public void println()
 660       {
 661         mappingDetails.append(NEWLINE);
 662       }
 663     };
 664
 665     maxAlignseq.printAlignment(ps);
 666
 667     mappingDetails.append(NEWLINE).append("PDB start/end ");
 668     mappingDetails.append(String.valueOf(maxAlignseq.seq2start))
 669             .append(" ");
 670     mappingDetails.append(String.valueOf(maxAlignseq.seq2end));
 671     mappingDetails.append(NEWLINE).append("SEQ start/end ");
 672     mappingDetails.append(
 673             String.valueOf(maxAlignseq.seq1start + (seq.getStart() - 1)))
 674             .append(" ");
 675     mappingDetails.append(String.valueOf(maxAlignseq.seq1end
 676             + (seq.getStart() - 1)));
 677     mappingDetails.append(NEWLINE);
 678     maxChain.makeExactMapping(maxAlignseq, seq);
 679     jalview.datamodel.Mapping sqmpping = maxAlignseq
 680             .getMappingFromS1(false);
 681     maxChain.transferRESNUMFeatures(seq, null);
 682
 683     HashMap<Integer, int[]> mapping = new HashMap<Integer, int[]>();
 684     int resNum = -10000;
 685     int index = 0;
 686     char insCode = ' ';
 687
 688     do
 689     {
 690       Atom tmp = maxChain.atoms.elementAt(index);
 691       if ((resNum != tmp.resNumber || insCode != tmp.insCode)
 692               && tmp.alignmentMapping != -1)
 693       {
 694         resNum = tmp.resNumber;
 695         insCode = tmp.insCode;
 696         if (tmp.alignmentMapping >= -1)
 697         {
 698           mapping.put(tmp.alignmentMapping + 1, new int[] { tmp.resNumber,
 699               tmp.atomIndex });
 700         }
 701       }
 702
 703       index++;
 704     } while (index < maxChain.atoms.size());
 705
 706     StructureMapping nwMapping = new StructureMapping(seq, pdbFile,
 707             pdb.getId(), maxChainId, mapping, mappingDetails.toString());
 708     maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 709     return nwMapping;
 710   }
 711
 712   public void removeStructureViewerListener(Object svl, String[] pdbfiles)
 713   {
 714     listeners.removeElement(svl);
 715     if (svl instanceof SequenceListener)
 716     {
 717       for (int i = 0; i < listeners.size(); i++)
 718       {
 719         if (listeners.elementAt(i) instanceof StructureListener)
 720         {
 721           ((StructureListener) listeners.elementAt(i))
 722                   .releaseReferences(svl);
 723         }
 724       }
 725     }
 726
 727     if (pdbfiles == null)
 728     {
 729       return;
 730     }
 731
 732     /*
 733      * Remove mappings to the closed listener's PDB files, but first check if
 734      * another listener is still interested
 735      */
 736     List<String> pdbs = new ArrayList<String>(Arrays.asList(pdbfiles));
 737
 738     StructureListener sl;
 739     for (int i = 0; i < listeners.size(); i++)
 740     {
 741       if (listeners.elementAt(i) instanceof StructureListener)
 742       {
 743         sl = (StructureListener) listeners.elementAt(i);
 744         for (String pdbfile : sl.getStructureFiles())
 745         {
 746           pdbs.remove(pdbfile);
 747         }
 748       }
 749     }
 750
 751     /*
 752      * Rebuild the mappings set, retaining only those which are for 'other' PDB
 753      * files
 754      */
 755     if (pdbs.size() > 0)
 756     {
 757       List<StructureMapping> tmp = new ArrayList<StructureMapping>();
 758       for (StructureMapping sm : mappings)
 759       {
 760         if (!pdbs.contains(sm.pdbfile))
 761         {
 762           tmp.add(sm);
 763         }
 764       }
 765
 766       mappings = tmp;
 767     }
 768   }
 769
 770   /**
 771    * Propagate mouseover of a single position in a structure
 772    *
 773    * @param pdbResNum
 774    * @param chain
 775    * @param pdbfile
 776    */
 777   public void mouseOverStructure(int pdbResNum, String chain, String pdbfile)
 778   {
 779     AtomSpec atomSpec = new AtomSpec(pdbfile, chain, pdbResNum, 0);
 780     List<AtomSpec> atoms = Collections.singletonList(atomSpec);
 781     mouseOverStructure(atoms);
 782   }
 783
 784   /**
 785    * Propagate mouseover or selection of multiple positions in a structure
 786    *
 787    * @param atoms
 788    */
 789   public void mouseOverStructure(List<AtomSpec> atoms)
 790   {
 791     if (listeners == null)
 792     {
 793       // old or prematurely sent event
 794       return;
 795     }
 796     boolean hasSequenceListener = false;
 797     for (int i = 0; i < listeners.size(); i++)
 798     {
 799       if (listeners.elementAt(i) instanceof SequenceListener)
 800       {
 801         hasSequenceListener = true;
 802       }
 803     }
 804     if (!hasSequenceListener)
 805     {
 806       return;
 807     }
 808
 809     SearchResultsI results = findAlignmentPositionsForStructurePositions(atoms);
 810     for (Object li : listeners)
 811     {
 812       if (li instanceof SequenceListener)
 813       {
 814         ((SequenceListener) li).highlightSequence(results);
 815       }
 816     }
 817   }
 818
 819   /**
 820    * Constructs a SearchResults object holding regions (if any) in the Jalview
 821    * alignment which have a mapping to the structure viewer positions in the
 822    * supplied list
 823    *
 824    * @param atoms
 825    * @return
 826    */
 827   public SearchResultsI findAlignmentPositionsForStructurePositions(
 828           List<AtomSpec> atoms)
 829   {
 830     SearchResultsI results = new SearchResults();
 831     for (AtomSpec atom : atoms)
 832     {
 833       SequenceI lastseq = null;
 834       int lastipos = -1;
 835       for (StructureMapping sm : mappings)
 836       {
 837         if (sm.pdbfile.equals(atom.getPdbFile())
 838                 && sm.pdbchain.equals(atom.getChain()))
 839         {
 840           int indexpos = sm.getSeqPos(atom.getPdbResNum());
 841           if (lastipos != indexpos && lastseq != sm.sequence)
 842           {
 843             results.addResult(sm.sequence, indexpos, indexpos);
 844             lastipos = indexpos;
 845             lastseq = sm.sequence;
 846             // construct highlighted sequence list
 847             for (AlignedCodonFrame acf : seqmappings)
 848             {
 849               acf.markMappedRegion(sm.sequence, indexpos, results);
 850             }
 851           }
 852         }
 853       }
 854     }
 855     return results;
 856   }
 857
 858   /**
 859    * highlight regions associated with a position (indexpos) in seq
 860    *
 861    * @param seq
 862    *          the sequence that the mouse over occurred on
 863    * @param indexpos
 864    *          the absolute position being mouseovered in seq (0 to seq.length())
 865    * @param seqPos
 866    *          the sequence position (if -1, seq.findPosition is called to
 867    *          resolve the residue number)
 868    */
 869   public void mouseOverSequence(SequenceI seq, int indexpos, int seqPos,
 870           VamsasSource source)
 871   {
 872     boolean hasSequenceListeners = handlingVamsasMo
 873             || !seqmappings.isEmpty();
 874     SearchResultsI results = null;
 875     if (seqPos == -1)
 876     {
 877       seqPos = seq.findPosition(indexpos);
 878     }
 879     for (int i = 0; i < listeners.size(); i++)
 880     {
 881       Object listener = listeners.elementAt(i);
 882       if (listener == source)
 883       {
 884         // TODO listener (e.g. SeqPanel) is never == source (AlignViewport)
 885         // Temporary fudge with SequenceListener.getVamsasSource()
 886         continue;
 887       }
 888       if (listener instanceof StructureListener)
 889       {
 890         highlightStructure((StructureListener) listener, seq, seqPos);
 891       }
 892       else
 893       {
 894         if (listener instanceof SequenceListener)
 895         {
 896           final SequenceListener seqListener = (SequenceListener) listener;
 897           if (hasSequenceListeners
 898                   && seqListener.getVamsasSource() != source)
 899           {
 900             if (relaySeqMappings)
 901             {
 902               if (results == null)
 903               {
 904                 results = MappingUtils.buildSearchResults(seq, seqPos,
 905                         seqmappings);
 906               }
 907               if (handlingVamsasMo)
 908               {
 909                 results.addResult(seq, seqPos, seqPos);
 910
 911               }
 912               if (!results.isEmpty())
 913               {
 914                 seqListener.highlightSequence(results);
 915               }
 916             }
 917           }
 918         }
 919         else if (listener instanceof VamsasListener && !handlingVamsasMo)
 920         {
 921           ((VamsasListener) listener).mouseOverSequence(seq, indexpos,
 922                   source);
 923         }
 924         else if (listener instanceof SecondaryStructureListener)
 925         {
 926           ((SecondaryStructureListener) listener).mouseOverSequence(seq,
 927                   indexpos, seqPos);
 928         }
 929       }
 930     }
 931   }
 932
 933   /**
 934    * Send suitable messages to a StructureListener to highlight atoms
 935    * corresponding to the given sequence position(s)
 936    *
 937    * @param sl
 938    * @param seq
 939    * @param positions
 940    */
 941   public void highlightStructure(StructureListener sl, SequenceI seq,
 942           int... positions)
 943   {
 944     if (!sl.isListeningFor(seq))
 945     {
 946       return;
 947     }
 948     int atomNo;
 949     List<AtomSpec> atoms = new ArrayList<AtomSpec>();
 950     for (StructureMapping sm : mappings)
 951     {
 952       if (sm.sequence == seq
 953               || sm.sequence == seq.getDatasetSequence()
 954               || (sm.sequence.getDatasetSequence() != null && sm.sequence
 955                       .getDatasetSequence() == seq.getDatasetSequence()))
 956       {
 957         for (int index : positions)
 958         {
 959           atomNo = sm.getAtomNum(index);
 960
 961           if (atomNo > 0)
 962           {
 963             atoms.add(new AtomSpec(sm.pdbfile, sm.pdbchain, sm
 964                     .getPDBResNum(index), atomNo));
 965           }
 966         }
 967       }
 968     }
 969     sl.highlightAtoms(atoms);
 970   }
 971
 972   /**
 973    * true if a mouse over event from an external (ie Vamsas) source is being
 974    * handled
 975    */
 976   boolean handlingVamsasMo = false;
 977
 978   long lastmsg = 0;
 979
 980   /**
 981    * as mouseOverSequence but only route event to SequenceListeners
 982    *
 983    * @param sequenceI
 984    * @param position
 985    *          in an alignment sequence
 986    */
 987   public void mouseOverVamsasSequence(SequenceI sequenceI, int position,
 988           VamsasSource source)
 989   {
 990     handlingVamsasMo = true;
 991     long msg = sequenceI.hashCode() * (1 + position);
 992     if (lastmsg != msg)
 993     {
 994       lastmsg = msg;
 995       mouseOverSequence(sequenceI, position, -1, source);
 996     }
 997     handlingVamsasMo = false;
 998   }
 999
1000   public Annotation[] colourSequenceFromStructure(SequenceI seq,
1001           String pdbid)
1002   {
1003     return null;
1004     // THIS WILL NOT BE AVAILABLE IN JALVIEW 2.3,
1005     // UNTIL THE COLOUR BY ANNOTATION IS REWORKED
1006     /*
1007      * Annotation [] annotations = new Annotation[seq.getLength()];
1008      *
1009      * StructureListener sl; int atomNo = 0; for (int i = 0; i <
1010      * listeners.size(); i++) { if (listeners.elementAt(i) instanceof
1011      * StructureListener) { sl = (StructureListener) listeners.elementAt(i);
1012      *
1013      * for (int j = 0; j < mappings.length; j++) {
1014      *
1015      * if (mappings[j].sequence == seq && mappings[j].getPdbId().equals(pdbid)
1016      * && mappings[j].pdbfile.equals(sl.getPdbFile())) {
1017      * System.out.println(pdbid+" "+mappings[j].getPdbId() +"
1018      * "+mappings[j].pdbfile);
1019      *
1020      * java.awt.Color col; for(int index=0; index<seq.getLength(); index++) {
1021      * if(jalview.util.Comparison.isGap(seq.getCharAt(index))) continue;
1022      *
1023      * atomNo = mappings[j].getAtomNum(seq.findPosition(index)); col =
1024      * java.awt.Color.white; if (atomNo > 0) { col = sl.getColour(atomNo,
1025      * mappings[j].getPDBResNum(index), mappings[j].pdbchain,
1026      * mappings[j].pdbfile); }
1027      *
1028      * annotations[index] = new Annotation("X",null,' ',0,col); } return
1029      * annotations; } } } }
1030      *
1031      * return annotations;
1032      */
1033   }
1034
1035   public void structureSelectionChanged()
1036   {
1037   }
1038
1039   public void sequenceSelectionChanged()
1040   {
1041   }
1042
1043   public void sequenceColoursChanged(Object source)
1044   {
1045     StructureListener sl;
1046     for (int i = 0; i < listeners.size(); i++)
1047     {
1048       if (listeners.elementAt(i) instanceof StructureListener)
1049       {
1050         sl = (StructureListener) listeners.elementAt(i);
1051         sl.updateColours(source);
1052       }
1053     }
1054   }
1055
1056   public StructureMapping[] getMapping(String pdbfile)
1057   {
1058     List<StructureMapping> tmp = new ArrayList<StructureMapping>();
1059     for (StructureMapping sm : mappings)
1060     {
1061       if (sm.pdbfile.equals(pdbfile))
1062       {
1063         tmp.add(sm);
1064       }
1065     }
1066     return tmp.toArray(new StructureMapping[tmp.size()]);
1067   }
1068
1069   /**
1070    * Returns a readable description of all mappings for the given pdbfile to any
1071    * of the given sequences
1072    *
1073    * @param pdbfile
1074    * @param seqs
1075    * @return
1076    */
1077   public String printMappings(String pdbfile, List<SequenceI> seqs)
1078   {
1079     if (pdbfile == null || seqs == null || seqs.isEmpty())
1080     {
1081       return "";
1082     }
1083
1084     StringBuilder sb = new StringBuilder(64);
1085     for (StructureMapping sm : mappings)
1086     {
1087       if (sm.pdbfile.equals(pdbfile) && seqs.contains(sm.sequence))
1088       {
1089         sb.append(sm.mappingDetails);
1090         sb.append(NEWLINE);
1091         // separator makes it easier to read multiple mappings
1092         sb.append("=====================");
1093         sb.append(NEWLINE);
1094       }
1095     }
1096     sb.append(NEWLINE);
1097
1098     return sb.toString();
1099   }
1100
1101   /**
1102    * Remove the given mapping
1103    *
1104    * @param acf
1105    */
1106   public void deregisterMapping(AlignedCodonFrame acf)
1107   {
1108     if (acf != null)
1109     {
1110       boolean removed = seqmappings.remove(acf);
1111       if (removed && seqmappings.isEmpty())
1112       { // debug
1113         System.out.println("All mappings removed");
1114       }
1115     }
1116   }
1117
1118   /**
1119    * Add each of the given codonFrames to the stored set, if not aready present.
1120    *
1121    * @param mappings
1122    */
1123   public void registerMappings(List<AlignedCodonFrame> mappings)
1124   {
1125     if (mappings != null)
1126     {
1127       for (AlignedCodonFrame acf : mappings)
1128       {
1129         registerMapping(acf);
1130       }
1131     }
1132   }
1133
1134   /**
1135    * Add the given mapping to the stored set, unless already stored.
1136    */
1137   public void registerMapping(AlignedCodonFrame acf)
1138   {
1139     if (acf != null)
1140     {
1141       if (!seqmappings.contains(acf))
1142       {
1143         seqmappings.add(acf);
1144       }
1145     }
1146   }
1147
1148   /**
1149    * Resets this object to its initial state by removing all registered
1150    * listeners, codon mappings, PDB file mappings
1151    */
1152   public void resetAll()
1153   {
1154     if (mappings != null)
1155     {
1156       mappings.clear();
1157     }
1158     if (seqmappings != null)
1159     {
1160       seqmappings.clear();
1161     }
1162     if (sel_listeners != null)
1163     {
1164       sel_listeners.clear();
1165     }
1166     if (listeners != null)
1167     {
1168       listeners.clear();
1169     }
1170     if (commandListeners != null)
1171     {
1172       commandListeners.clear();
1173     }
1174     if (view_listeners != null)
1175     {
1176       view_listeners.clear();
1177     }
1178     if (pdbFileNameId != null)
1179     {
1180       pdbFileNameId.clear();
1181     }
1182     if (pdbIdFileName != null)
1183     {
1184       pdbIdFileName.clear();
1185     }
1186   }
1187
1188   public void addSelectionListener(SelectionListener selecter)
1189   {
1190     if (!sel_listeners.contains(selecter))
1191     {
1192       sel_listeners.add(selecter);
1193     }
1194   }
1195
1196   public void removeSelectionListener(SelectionListener toremove)
1197   {
1198     if (sel_listeners.contains(toremove))
1199     {
1200       sel_listeners.remove(toremove);
1201     }
1202   }
1203
1204   public synchronized void sendSelection(
1205           jalview.datamodel.SequenceGroup selection,
1206           jalview.datamodel.ColumnSelection colsel, SelectionSource source)
1207   {
1208     for (SelectionListener slis : sel_listeners)
1209     {
1210       if (slis != source)
1211       {
1212         slis.selection(selection, colsel, source);
1213       }
1214     }
1215   }
1216
1217   Vector<AlignmentViewPanelListener> view_listeners = new Vector<AlignmentViewPanelListener>();
1218
1219   public synchronized void sendViewPosition(
1220           jalview.api.AlignmentViewPanel source, int startRes, int endRes,
1221           int startSeq, int endSeq)
1222   {
1223
1224     if (view_listeners != null && view_listeners.size() > 0)
1225     {
1226       Enumeration<AlignmentViewPanelListener> listeners = view_listeners
1227               .elements();
1228       while (listeners.hasMoreElements())
1229       {
1230         AlignmentViewPanelListener slis = listeners.nextElement();
1231         if (slis != source)
1232         {
1233           slis.viewPosition(startRes, endRes, startSeq, endSeq, source);
1234         }
1235         ;
1236       }
1237     }
1238   }
1239
1240   /**
1241    * release all references associated with this manager provider
1242    *
1243    * @param jalviewLite
1244    */
1245   public static void release(StructureSelectionManagerProvider jalviewLite)
1246   {
1247     // synchronized (instances)
1248     {
1249       if (instances == null)
1250       {
1251         return;
1252       }
1253       StructureSelectionManager mnger = (instances.get(jalviewLite));
1254       if (mnger != null)
1255       {
1256         instances.remove(jalviewLite);
1257         try
1258         {
1259           mnger.finalize();
1260         } catch (Throwable x)
1261         {
1262         }
1263       }
1264     }
1265   }
1266
1267   public void registerPDBEntry(PDBEntry pdbentry)
1268   {
1269     if (pdbentry.getFile() != null
1270             && pdbentry.getFile().trim().length() > 0)
1271     {
1272       registerPDBFile(pdbentry.getId(), pdbentry.getFile());
1273     }
1274   }
1275
1276   public void addCommandListener(CommandListener cl)
1277   {
1278     if (!commandListeners.contains(cl))
1279     {
1280       commandListeners.add(cl);
1281     }
1282   }
1283
1284   public boolean hasCommandListener(CommandListener cl)
1285   {
1286     return this.commandListeners.contains(cl);
1287   }
1288
1289   public boolean removeCommandListener(CommandListener l)
1290   {
1291     return commandListeners.remove(l);
1292   }
1293
1294   /**
1295    * Forward a command to any command listeners (except for the command's
1296    * source).
1297    *
1298    * @param command
1299    *          the command to be broadcast (in its form after being performed)
1300    * @param undo
1301    *          if true, the command was being 'undone'
1302    * @param source
1303    */
1304   public void commandPerformed(CommandI command, boolean undo,
1305           VamsasSource source)
1306   {
1307     for (CommandListener listener : commandListeners)
1308     {
1309       listener.mirrorCommand(command, undo, this, source);
1310     }
1311   }
1312
1313   /**
1314    * Returns a new CommandI representing the given command as mapped to the
1315    * given sequences. If no mapping could be made, or the command is not of a
1316    * mappable kind, returns null.
1317    *
1318    * @param command
1319    * @param undo
1320    * @param mapTo
1321    * @param gapChar
1322    * @return
1323    */
1324   public CommandI mapCommand(CommandI command, boolean undo,
1325           final AlignmentI mapTo, char gapChar)
1326   {
1327     if (command instanceof EditCommand)
1328     {
1329       return MappingUtils.mapEditCommand((EditCommand) command, undo,
1330               mapTo, gapChar, seqmappings);
1331     }
1332     else if (command instanceof OrderCommand)
1333     {
1334       return MappingUtils.mapOrderCommand((OrderCommand) command, undo,
1335               mapTo, seqmappings);
1336     }
1337     return null;
1338   }
1339
1340   public IProgressIndicator getProgressIndicator()
1341   {
1342     return progressIndicator;
1343   }
1344
1345   public void setProgressIndicator(IProgressIndicator progressIndicator)
1346   {
1347     this.progressIndicator = progressIndicator;
1348   }
1349
1350   public long getProgressSessionId()
1351   {
1352     return progressSessionId;
1353   }
1354
1355   public void setProgressSessionId(long progressSessionId)
1356   {
1357     this.progressSessionId = progressSessionId;
1358   }
1359
1360   public void setProgressBar(String message)
1361   {
1362     if (progressIndicator == null)
1363     {
1364       return;
1365     }
1366     progressIndicator.setProgressBar(message, progressSessionId);
1367   }
1368
1369   public List<AlignedCodonFrame> getSequenceMappings()
1370   {
1371     return seqmappings;
1372   }
1373
1374 }