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