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