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.HiddenColumns;
  33 import jalview.datamodel.PDBEntry;
  34 import jalview.datamodel.SearchResults;
  35 import jalview.datamodel.SearchResultsI;
  36 import jalview.datamodel.SequenceI;
  37 import jalview.ext.jmol.JmolParser;
  38 import jalview.gui.IProgressIndicator;
  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       pdb = new JmolParser(pdbFile, sourceType);
 389
 390       if (pdb.getId() != null && pdb.getId().trim().length() > 0
 391               && DataSourceType.FILE == sourceType)
 392       {
 393         registerPDBFile(pdb.getId().trim(), pdbFile);
 394       }
 395       // if PDBId is unavailable then skip SIFTS mapping execution path
 396       isMapUsingSIFTs = isMapUsingSIFTs && pdb.isPPDBIdAvailable();
 397
 398     } catch (Exception ex)
 399     {
 400       ex.printStackTrace();
 401       return null;
 402     }
 403
 404     try
 405     {
 406       if (isMapUsingSIFTs)
 407       {
 408         siftsClient = new SiftsClient(pdb);
 409       }
 410     } catch (SiftsException e)
 411     {
 412       isMapUsingSIFTs = false;
 413       e.printStackTrace();
 414     }
 415
 416     String targetChainId;
 417     for (int s = 0; s < sequenceArray.length; s++)
 418     {
 419       boolean infChain = true;
 420       final SequenceI seq = sequenceArray[s];
 421       SequenceI ds = seq;
 422       while (ds.getDatasetSequence() != null)
 423       {
 424         ds = ds.getDatasetSequence();
 425       }
 426
 427       if (targetChainIds != null && targetChainIds[s] != null)
 428       {
 429         infChain = false;
 430         targetChainId = targetChainIds[s];
 431       }
 432       else if (seq.getName().indexOf("|") > -1)
 433       {
 434         targetChainId = seq.getName().substring(
 435                 seq.getName().lastIndexOf("|") + 1);
 436         if (targetChainId.length() > 1)
 437         {
 438           if (targetChainId.trim().length() == 0)
 439           {
 440             targetChainId = " ";
 441           }
 442           else
 443           {
 444             // not a valid chain identifier
 445             targetChainId = "";
 446           }
 447         }
 448       }
 449       else
 450       {
 451         targetChainId = "";
 452       }
 453
 454       /*
 455        * Attempt pairwise alignment of the sequence with each chain in the PDB,
 456        * and remember the highest scoring chain
 457        */
 458       float max = -10;
 459       AlignSeq maxAlignseq = null;
 460       String maxChainId = " ";
 461       PDBChain maxChain = null;
 462       boolean first = true;
 463       for (PDBChain chain : pdb.getChains())
 464       {
 465         if (targetChainId.length() > 0 && !targetChainId.equals(chain.id)
 466                 && !infChain)
 467         {
 468           continue; // don't try to map chains don't match.
 469         }
 470         // TODO: correctly determine sequence type for mixed na/peptide
 471         // structures
 472         final String type = chain.isNa ? AlignSeq.DNA : AlignSeq.PEP;
 473         AlignSeq as = AlignSeq.doGlobalNWAlignment(seq, chain.sequence,
 474                 type);
 475         // equivalent to:
 476         // AlignSeq as = new AlignSeq(sequence[s], chain.sequence, type);
 477         // as.calcScoreMatrix();
 478         // as.traceAlignment();
 479
 480         if (first || as.maxscore > max
 481                 || (as.maxscore == max && chain.id.equals(targetChainId)))
 482         {
 483           first = false;
 484           maxChain = chain;
 485           max = as.maxscore;
 486           maxAlignseq = as;
 487           maxChainId = chain.id;
 488         }
 489       }
 490       if (maxChain == null)
 491       {
 492         continue;
 493       }
 494
 495       if (sourceType == DataSourceType.PASTE)
 496       {
 497         pdbFile = "INLINE" + pdb.getId();
 498       }
 499
 500       List<StructureMapping> seqToStrucMapping = new ArrayList<StructureMapping>();
 501       if (isMapUsingSIFTs && seq.isProtein())
 502       {
 503         setProgressBar(null);
 504         setProgressBar(MessageManager
 505                 .getString("status.obtaining_mapping_with_sifts"));
 506         jalview.datamodel.Mapping sqmpping = maxAlignseq
 507                 .getMappingFromS1(false);
 508         if (targetChainId != null && !targetChainId.trim().isEmpty())
 509         {
 510           StructureMapping siftsMapping;
 511           try
 512           {
 513             siftsMapping = getStructureMapping(seq, pdbFile, targetChainId,
 514                     pdb, maxChain, sqmpping, maxAlignseq);
 515             seqToStrucMapping.add(siftsMapping);
 516             maxChain.makeExactMapping(maxAlignseq, seq);
 517             maxChain.transferRESNUMFeatures(seq, null);// FIXME: is this
 518                                                        // "IEA:SIFTS" ?
 519             maxChain.transferResidueAnnotation(siftsMapping, sqmpping);
 520             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 521
 522           } catch (SiftsException e)
 523           {
 524             // fall back to NW alignment
 525             System.err.println(e.getMessage());
 526             StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 527                     targetChainId, maxChain, pdb, maxAlignseq);
 528             seqToStrucMapping.add(nwMapping);
 529             maxChain.makeExactMapping(maxAlignseq, seq);
 530             maxChain.transferRESNUMFeatures(seq, null); // FIXME: is this
 531                                                         // "IEA:Jalview" ?
 532             maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 533             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 534           }
 535         }
 536         else
 537         {
 538           List<StructureMapping> foundSiftsMappings = new ArrayList<StructureMapping>();
 539           for (PDBChain chain : pdb.getChains())
 540           {
 541             try
 542             {
 543               StructureMapping siftsMapping = getStructureMapping(seq,
 544                       pdbFile, chain.id, pdb, chain, sqmpping, maxAlignseq);
 545               foundSiftsMappings.add(siftsMapping);
 546             } catch (SiftsException e)
 547             {
 548               System.err.println(e.getMessage());
 549             }
 550           }
 551           if (!foundSiftsMappings.isEmpty())
 552           {
 553             seqToStrucMapping.addAll(foundSiftsMappings);
 554             maxChain.makeExactMapping(maxAlignseq, seq);
 555             maxChain.transferRESNUMFeatures(seq, null);// FIXME: is this
 556                                                        // "IEA:SIFTS" ?
 557             maxChain.transferResidueAnnotation(foundSiftsMappings.get(0),
 558                     sqmpping);
 559             ds.addPDBId(sqmpping.getTo().getAllPDBEntries().get(0));
 560           }
 561           else
 562           {
 563             StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 564                     maxChainId, maxChain, pdb, maxAlignseq);
 565             seqToStrucMapping.add(nwMapping);
 566             maxChain.transferRESNUMFeatures(seq, null); // FIXME: is this
 567                                                         // "IEA:Jalview" ?
 568             maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 569             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 570           }
 571         }
 572       }
 573       else
 574       {
 575         setProgressBar(null);
 576         setProgressBar(MessageManager
 577                 .getString("status.obtaining_mapping_with_nw_alignment"));
 578         StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 579                 maxChainId, maxChain, pdb, maxAlignseq);
 580         seqToStrucMapping.add(nwMapping);
 581         ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 582
 583       }
 584
 585       if (forStructureView)
 586       {
 587         mappings.addAll(seqToStrucMapping);
 588       }
 589     }
 590     return pdb;
 591   }
 592
 593   public void addStructureMapping(StructureMapping sm)
 594   {
 595     mappings.add(sm);
 596   }
 597
 598   /**
 599    * retrieve a mapping for seq from SIFTs using associated DBRefEntry for
 600    * uniprot or PDB
 601    *
 602    * @param seq
 603    * @param pdbFile
 604    * @param targetChainId
 605    * @param pdb
 606    * @param maxChain
 607    * @param sqmpping
 608    * @param maxAlignseq
 609    * @return
 610    * @throws SiftsException
 611    */
 612   private StructureMapping getStructureMapping(SequenceI seq,
 613           String pdbFile, String targetChainId, StructureFile pdb,
 614           PDBChain maxChain, jalview.datamodel.Mapping sqmpping,
 615           AlignSeq maxAlignseq) throws SiftsException
 616   {
 617     StructureMapping curChainMapping = siftsClient
 618             .getSiftsStructureMapping(seq, pdbFile, targetChainId);
 619     try
 620     {
 621       PDBChain chain = pdb.findChain(targetChainId);
 622       if (chain != null)
 623       {
 624         chain.transferResidueAnnotation(curChainMapping, sqmpping);
 625       }
 626     } catch (Exception e)
 627     {
 628       e.printStackTrace();
 629     }
 630     return curChainMapping;
 631   }
 632
 633   private StructureMapping getNWMappings(SequenceI seq, String pdbFile,
 634           String maxChainId, PDBChain maxChain, StructureFile pdb,
 635           AlignSeq maxAlignseq)
 636   {
 637     final StringBuilder mappingDetails = new StringBuilder(128);
 638     mappingDetails.append(NEWLINE).append(
 639             "Sequence \u27f7 Structure mapping details");
 640     mappingDetails.append(NEWLINE);
 641     mappingDetails
 642             .append("Method: inferred with Needleman & Wunsch alignment");
 643     mappingDetails.append(NEWLINE).append("PDB Sequence is :")
 644             .append(NEWLINE).append("Sequence = ")
 645             .append(maxChain.sequence.getSequenceAsString());
 646     mappingDetails.append(NEWLINE).append("No of residues = ")
 647             .append(maxChain.residues.size()).append(NEWLINE)
 648             .append(NEWLINE);
 649     PrintStream ps = new PrintStream(System.out)
 650     {
 651       @Override
 652       public void print(String x)
 653       {
 654         mappingDetails.append(x);
 655       }
 656
 657       @Override
 658       public void println()
 659       {
 660         mappingDetails.append(NEWLINE);
 661       }
 662     };
 663
 664     maxAlignseq.printAlignment(ps);
 665
 666     mappingDetails.append(NEWLINE).append("PDB start/end ");
 667     mappingDetails.append(String.valueOf(maxAlignseq.seq2start))
 668             .append(" ");
 669     mappingDetails.append(String.valueOf(maxAlignseq.seq2end));
 670     mappingDetails.append(NEWLINE).append("SEQ start/end ");
 671     mappingDetails.append(
 672             String.valueOf(maxAlignseq.seq1start + (seq.getStart() - 1)))
 673             .append(" ");
 674     mappingDetails.append(String.valueOf(maxAlignseq.seq1end
 675             + (seq.getStart() - 1)));
 676     mappingDetails.append(NEWLINE);
 677     maxChain.makeExactMapping(maxAlignseq, seq);
 678     jalview.datamodel.Mapping sqmpping = maxAlignseq
 679             .getMappingFromS1(false);
 680     maxChain.transferRESNUMFeatures(seq, null);
 681
 682     HashMap<Integer, int[]> mapping = new HashMap<Integer, int[]>();
 683     int resNum = -10000;
 684     int index = 0;
 685     char insCode = ' ';
 686
 687     do
 688     {
 689       Atom tmp = maxChain.atoms.elementAt(index);
 690       if ((resNum != tmp.resNumber || insCode != tmp.insCode)
 691               && tmp.alignmentMapping != -1)
 692       {
 693         resNum = tmp.resNumber;
 694         insCode = tmp.insCode;
 695         if (tmp.alignmentMapping >= -1)
 696         {
 697           mapping.put(tmp.alignmentMapping + 1, new int[] { tmp.resNumber,
 698               tmp.atomIndex });
 699         }
 700       }
 701
 702       index++;
 703     } while (index < maxChain.atoms.size());
 704
 705     StructureMapping nwMapping = new StructureMapping(seq, pdbFile,
 706             pdb.getId(), maxChainId, mapping, mappingDetails.toString());
 707     maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 708     return nwMapping;
 709   }
 710
 711   public void removeStructureViewerListener(Object svl, String[] pdbfiles)
 712   {
 713     listeners.removeElement(svl);
 714     if (svl instanceof SequenceListener)
 715     {
 716       for (int i = 0; i < listeners.size(); i++)
 717       {
 718         if (listeners.elementAt(i) instanceof StructureListener)
 719         {
 720           ((StructureListener) listeners.elementAt(i))
 721                   .releaseReferences(svl);
 722         }
 723       }
 724     }
 725
 726     if (pdbfiles == null)
 727     {
 728       return;
 729     }
 730
 731     /*
 732      * Remove mappings to the closed listener's PDB files, but first check if
 733      * another listener is still interested
 734      */
 735     List<String> pdbs = new ArrayList<String>(Arrays.asList(pdbfiles));
 736
 737     StructureListener sl;
 738     for (int i = 0; i < listeners.size(); i++)
 739     {
 740       if (listeners.elementAt(i) instanceof StructureListener)
 741       {
 742         sl = (StructureListener) listeners.elementAt(i);
 743         for (String pdbfile : sl.getPdbFile())
 744         {
 745           pdbs.remove(pdbfile);
 746         }
 747       }
 748     }
 749
 750     /*
 751      * Rebuild the mappings set, retaining only those which are for 'other' PDB
 752      * files
 753      */
 754     if (pdbs.size() > 0)
 755     {
 756       List<StructureMapping> tmp = new ArrayList<StructureMapping>();
 757       for (StructureMapping sm : mappings)
 758       {
 759         if (!pdbs.contains(sm.pdbfile))
 760         {
 761           tmp.add(sm);
 762         }
 763       }
 764
 765       mappings = tmp;
 766     }
 767   }
 768
 769   /**
 770    * Propagate mouseover of a single position in a structure
 771    *
 772    * @param pdbResNum
 773    * @param chain
 774    * @param pdbfile
 775    */
 776   public void mouseOverStructure(int pdbResNum, String chain, String pdbfile)
 777   {
 778     AtomSpec atomSpec = new AtomSpec(pdbfile, chain, pdbResNum, 0);
 779     List<AtomSpec> atoms = Collections.singletonList(atomSpec);
 780     mouseOverStructure(atoms);
 781   }
 782
 783   /**
 784    * Propagate mouseover or selection of multiple positions in a structure
 785    *
 786    * @param atoms
 787    */
 788   public void mouseOverStructure(List<AtomSpec> atoms)
 789   {
 790     if (listeners == null)
 791     {
 792       // old or prematurely sent event
 793       return;
 794     }
 795     boolean hasSequenceListener = false;
 796     for (int i = 0; i < listeners.size(); i++)
 797     {
 798       if (listeners.elementAt(i) instanceof SequenceListener)
 799       {
 800         hasSequenceListener = true;
 801       }
 802     }
 803     if (!hasSequenceListener)
 804     {
 805       return;
 806     }
 807
 808     SearchResultsI results = findAlignmentPositionsForStructurePositions(atoms);
 809     for (Object li : listeners)
 810     {
 811       if (li instanceof SequenceListener)
 812       {
 813         ((SequenceListener) li).highlightSequence(results);
 814       }
 815     }
 816   }
 817
 818   /**
 819    * Constructs a SearchResults object holding regions (if any) in the Jalview
 820    * alignment which have a mapping to the structure viewer positions in the
 821    * supplied list
 822    *
 823    * @param atoms
 824    * @return
 825    */
 826   public SearchResultsI findAlignmentPositionsForStructurePositions(
 827           List<AtomSpec> atoms)
 828   {
 829     SearchResultsI results = new SearchResults();
 830     for (AtomSpec atom : atoms)
 831     {
 832       SequenceI lastseq = null;
 833       int lastipos = -1;
 834       for (StructureMapping sm : mappings)
 835       {
 836         if (sm.pdbfile.equals(atom.getPdbFile())
 837                 && sm.pdbchain.equals(atom.getChain()))
 838         {
 839           int indexpos = sm.getSeqPos(atom.getPdbResNum());
 840           if (lastipos != indexpos && lastseq != sm.sequence)
 841           {
 842             results.addResult(sm.sequence, indexpos, indexpos);
 843             lastipos = indexpos;
 844             lastseq = sm.sequence;
 845             // construct highlighted sequence list
 846             for (AlignedCodonFrame acf : seqmappings)
 847             {
 848               acf.markMappedRegion(sm.sequence, indexpos, results);
 849             }
 850           }
 851         }
 852       }
 853     }
 854     return results;
 855   }
 856
 857   /**
 858    * highlight regions associated with a position (indexpos) in seq
 859    *
 860    * @param seq
 861    *          the sequence that the mouse over occurred on
 862    * @param indexpos
 863    *          the absolute position being mouseovered in seq (0 to seq.length())
 864    * @param seqPos
 865    *          the sequence position (if -1, seq.findPosition is called to
 866    *          resolve the residue number)
 867    */
 868   public void mouseOverSequence(SequenceI seq, int indexpos, int seqPos,
 869           VamsasSource source)
 870   {
 871     boolean hasSequenceListeners = handlingVamsasMo
 872             || !seqmappings.isEmpty();
 873     SearchResultsI results = null;
 874     if (seqPos == -1)
 875     {
 876       seqPos = seq.findPosition(indexpos);
 877     }
 878     for (int i = 0; i < listeners.size(); i++)
 879     {
 880       Object listener = listeners.elementAt(i);
 881       if (listener == source)
 882       {
 883         // TODO listener (e.g. SeqPanel) is never == source (AlignViewport)
 884         // Temporary fudge with SequenceListener.getVamsasSource()
 885         continue;
 886       }
 887       if (listener instanceof StructureListener)
 888       {
 889         highlightStructure((StructureListener) listener, seq, seqPos);
 890       }
 891       else
 892       {
 893         if (listener instanceof SequenceListener)
 894         {
 895           final SequenceListener seqListener = (SequenceListener) listener;
 896           if (hasSequenceListeners
 897                   && seqListener.getVamsasSource() != source)
 898           {
 899             if (relaySeqMappings)
 900             {
 901               if (results == null)
 902               {
 903                 results = MappingUtils.buildSearchResults(seq, seqPos,
 904                         seqmappings);
 905               }
 906               if (handlingVamsasMo)
 907               {
 908                 results.addResult(seq, seqPos, seqPos);
 909
 910               }
 911               if (!results.isEmpty())
 912               {
 913                 seqListener.highlightSequence(results);
 914               }
 915             }
 916           }
 917         }
 918         else if (listener instanceof VamsasListener && !handlingVamsasMo)
 919         {
 920           ((VamsasListener) listener).mouseOverSequence(seq, indexpos,
 921                   source);
 922         }
 923         else if (listener instanceof SecondaryStructureListener)
 924         {
 925           ((SecondaryStructureListener) listener).mouseOverSequence(seq,
 926                   indexpos, seqPos);
 927         }
 928       }
 929     }
 930   }
 931
 932   /**
 933    * Send suitable messages to a StructureListener to highlight atoms
 934    * corresponding to the given sequence position(s)
 935    *
 936    * @param sl
 937    * @param seq
 938    * @param positions
 939    */
 940   public void highlightStructure(StructureListener sl, SequenceI seq,
 941           int... positions)
 942   {
 943     if (!sl.isListeningFor(seq))
 944     {
 945       return;
 946     }
 947     int atomNo;
 948     List<AtomSpec> atoms = new ArrayList<AtomSpec>();
 949     for (StructureMapping sm : mappings)
 950     {
 951       if (sm.sequence == seq
 952               || sm.sequence == seq.getDatasetSequence()
 953               || (sm.sequence.getDatasetSequence() != null && sm.sequence
 954                       .getDatasetSequence() == seq.getDatasetSequence()))
 955       {
 956         for (int index : positions)
 957         {
 958           atomNo = sm.getAtomNum(index);
 959
 960           if (atomNo > 0)
 961           {
 962             atoms.add(new AtomSpec(sm.pdbfile, sm.pdbchain, sm
 963                     .getPDBResNum(index), atomNo));
 964           }
 965         }
 966       }
 967     }
 968     sl.highlightAtoms(atoms);
 969   }
 970
 971   /**
 972    * true if a mouse over event from an external (ie Vamsas) source is being
 973    * handled
 974    */
 975   boolean handlingVamsasMo = false;
 976
 977   long lastmsg = 0;
 978
 979   /**
 980    * as mouseOverSequence but only route event to SequenceListeners
 981    *
 982    * @param sequenceI
 983    * @param position
 984    *          in an alignment sequence
 985    */
 986   public void mouseOverVamsasSequence(SequenceI sequenceI, int position,
 987           VamsasSource source)
 988   {
 989     handlingVamsasMo = true;
 990     long msg = sequenceI.hashCode() * (1 + position);
 991     if (lastmsg != msg)
 992     {
 993       lastmsg = msg;
 994       mouseOverSequence(sequenceI, position, -1, source);
 995     }
 996     handlingVamsasMo = false;
 997   }
 998
 999   public Annotation[] colourSequenceFromStructure(SequenceI seq,
1000           String pdbid)
1001   {
1002     return null;
1003     // THIS WILL NOT BE AVAILABLE IN JALVIEW 2.3,
1004     // UNTIL THE COLOUR BY ANNOTATION IS REWORKED
1005     /*
1006      * Annotation [] annotations = new Annotation[seq.getLength()];
1007      *
1008      * StructureListener sl; int atomNo = 0; for (int i = 0; i <
1009      * listeners.size(); i++) { if (listeners.elementAt(i) instanceof
1010      * StructureListener) { sl = (StructureListener) listeners.elementAt(i);
1011      *
1012      * for (int j = 0; j < mappings.length; j++) {
1013      *
1014      * if (mappings[j].sequence == seq && mappings[j].getPdbId().equals(pdbid)
1015      * && mappings[j].pdbfile.equals(sl.getPdbFile())) {
1016      * System.out.println(pdbid+" "+mappings[j].getPdbId() +"
1017      * "+mappings[j].pdbfile);
1018      *
1019      * java.awt.Color col; for(int index=0; index<seq.getLength(); index++) {
1020      * if(jalview.util.Comparison.isGap(seq.getCharAt(index))) continue;
1021      *
1022      * atomNo = mappings[j].getAtomNum(seq.findPosition(index)); col =
1023      * java.awt.Color.white; if (atomNo > 0) { col = sl.getColour(atomNo,
1024      * mappings[j].getPDBResNum(index), mappings[j].pdbchain,
1025      * mappings[j].pdbfile); }
1026      *
1027      * annotations[index] = new Annotation("X",null,' ',0,col); } return
1028      * annotations; } } } }
1029      *
1030      * return annotations;
1031      */
1032   }
1033
1034   public void structureSelectionChanged()
1035   {
1036   }
1037
1038   public void sequenceSelectionChanged()
1039   {
1040   }
1041
1042   public void sequenceColoursChanged(Object source)
1043   {
1044     StructureListener sl;
1045     for (int i = 0; i < listeners.size(); i++)
1046     {
1047       if (listeners.elementAt(i) instanceof StructureListener)
1048       {
1049         sl = (StructureListener) listeners.elementAt(i);
1050         sl.updateColours(source);
1051       }
1052     }
1053   }
1054
1055   public StructureMapping[] getMapping(String pdbfile)
1056   {
1057     List<StructureMapping> tmp = new ArrayList<StructureMapping>();
1058     for (StructureMapping sm : mappings)
1059     {
1060       if (sm.pdbfile.equals(pdbfile))
1061       {
1062         tmp.add(sm);
1063       }
1064     }
1065     return tmp.toArray(new StructureMapping[tmp.size()]);
1066   }
1067
1068   /**
1069    * Returns a readable description of all mappings for the given pdbfile to any
1070    * of the given sequences
1071    *
1072    * @param pdbfile
1073    * @param seqs
1074    * @return
1075    */
1076   public String printMappings(String pdbfile, List<SequenceI> seqs)
1077   {
1078     if (pdbfile == null || seqs == null || seqs.isEmpty())
1079     {
1080       return "";
1081     }
1082
1083     StringBuilder sb = new StringBuilder(64);
1084     for (StructureMapping sm : mappings)
1085     {
1086       if (sm.pdbfile.equals(pdbfile) && seqs.contains(sm.sequence))
1087       {
1088         sb.append(sm.mappingDetails);
1089         sb.append(NEWLINE);
1090         // separator makes it easier to read multiple mappings
1091         sb.append("=====================");
1092         sb.append(NEWLINE);
1093       }
1094     }
1095     sb.append(NEWLINE);
1096
1097     return sb.toString();
1098   }
1099
1100   /**
1101    * Remove the given mapping
1102    *
1103    * @param acf
1104    */
1105   public void deregisterMapping(AlignedCodonFrame acf)
1106   {
1107     if (acf != null)
1108     {
1109       boolean removed = seqmappings.remove(acf);
1110       if (removed && seqmappings.isEmpty())
1111       { // debug
1112         System.out.println("All mappings removed");
1113       }
1114     }
1115   }
1116
1117   /**
1118    * Add each of the given codonFrames to the stored set, if not aready present.
1119    *
1120    * @param mappings
1121    */
1122   public void registerMappings(List<AlignedCodonFrame> mappings)
1123   {
1124     if (mappings != null)
1125     {
1126       for (AlignedCodonFrame acf : mappings)
1127       {
1128         registerMapping(acf);
1129       }
1130     }
1131   }
1132
1133   /**
1134    * Add the given mapping to the stored set, unless already stored.
1135    */
1136   public void registerMapping(AlignedCodonFrame acf)
1137   {
1138     if (acf != null)
1139     {
1140       if (!seqmappings.contains(acf))
1141       {
1142         seqmappings.add(acf);
1143       }
1144     }
1145   }
1146
1147   /**
1148    * Resets this object to its initial state by removing all registered
1149    * listeners, codon mappings, PDB file mappings
1150    */
1151   public void resetAll()
1152   {
1153     if (mappings != null)
1154     {
1155       mappings.clear();
1156     }
1157     if (seqmappings != null)
1158     {
1159       seqmappings.clear();
1160     }
1161     if (sel_listeners != null)
1162     {
1163       sel_listeners.clear();
1164     }
1165     if (listeners != null)
1166     {
1167       listeners.clear();
1168     }
1169     if (commandListeners != null)
1170     {
1171       commandListeners.clear();
1172     }
1173     if (view_listeners != null)
1174     {
1175       view_listeners.clear();
1176     }
1177     if (pdbFileNameId != null)
1178     {
1179       pdbFileNameId.clear();
1180     }
1181     if (pdbIdFileName != null)
1182     {
1183       pdbIdFileName.clear();
1184     }
1185   }
1186
1187   public void addSelectionListener(SelectionListener selecter)
1188   {
1189     if (!sel_listeners.contains(selecter))
1190     {
1191       sel_listeners.add(selecter);
1192     }
1193   }
1194
1195   public void removeSelectionListener(SelectionListener toremove)
1196   {
1197     if (sel_listeners.contains(toremove))
1198     {
1199       sel_listeners.remove(toremove);
1200     }
1201   }
1202
1203   public synchronized void sendSelection(
1204           jalview.datamodel.SequenceGroup selection,
1205           jalview.datamodel.ColumnSelection colsel, HiddenColumns hidden,
1206           SelectionSource source)
1207   {
1208     for (SelectionListener slis : sel_listeners)
1209     {
1210       if (slis != source)
1211       {
1212         slis.selection(selection, colsel, hidden, 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 }