src/jalview/structure/StructureSelectionManager.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9.0b2)
   3  * Copyright (C) 2015 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    * create sequence structure mappings between each sequence and the given
 332    * pdbFile (retrieved via the given protocol).
 333    *
 334    * @param forStructureView
 335    *          when true, record the mapping for use in mouseOvers
 336    *
 337    * @param sequenceArray
 338    *          - one or more sequences to be mapped to pdbFile
 339    * @param targetChainIds
 340    *          - optional chain specification for mapping each sequence to pdb
 341    *          (may be nill, individual elements may be nill)
 342    * @param pdbFile
 343    *          - structure data resource
 344    * @param protocol
 345    *          - how to resolve data from resource
 346    * @return null or the structure data parsed as a pdb file
 347    */
 348   synchronized public StructureFile setMapping(boolean forStructureView,
 349           SequenceI[] sequenceArray, String[] targetChainIds,
 350           String pdbFile, String protocol)
 351   {
 352     /*
 353      * There will be better ways of doing this in the future, for now we'll use
 354      * the tried and tested MCview pdb mapping
 355      */
 356     boolean parseSecStr = processSecondaryStructure;
 357     if (isPDBFileRegistered(pdbFile))
 358     {
 359       for (SequenceI sq : sequenceArray)
 360       {
 361         SequenceI ds = sq;
 362         while (ds.getDatasetSequence() != null)
 363         {
 364           ds = ds.getDatasetSequence();
 365         }
 366         ;
 367         if (ds.getAnnotation() != null)
 368         {
 369           for (AlignmentAnnotation ala : ds.getAnnotation())
 370           {
 371             // false if any annotation present from this structure
 372             // JBPNote this fails for jmol/chimera view because the *file* is
 373             // passed, not the structure data ID -
 374             if (PDBfile.isCalcIdForFile(ala, findIdForPDBFile(pdbFile)))
 375             {
 376               parseSecStr = false;
 377             }
 378           }
 379         }
 380       }
 381     }
 382     StructureFile pdb = null;
 383     boolean isMapUsingSIFTs = SiftsSettings.isMapWithSifts();
 384     try
 385     {
 386       pdb = new JmolParser(pdbFile, protocol);
 387
 388       if (pdb.getId() != null && pdb.getId().trim().length() > 0
 389               && AppletFormatAdapter.FILE.equals(protocol))
 390       {
 391         registerPDBFile(pdb.getId().trim(), pdbFile);
 392       }
 393     } catch (Exception ex)
 394     {
 395       ex.printStackTrace();
 396       return null;
 397     }
 398
 399     try
 400     {
 401       if (isMapUsingSIFTs)
 402       {
 403         siftsClient = new SiftsClient(pdb);
 404       }
 405     } catch (SiftsException e)
 406     {
 407       isMapUsingSIFTs = false;
 408       e.printStackTrace();
 409     }
 410
 411     String targetChainId;
 412     for (int s = 0; s < sequenceArray.length; s++)
 413     {
 414       boolean infChain = true;
 415       final SequenceI seq = sequenceArray[s];
 416       SequenceI ds = seq;
 417       while (ds.getDatasetSequence() != null)
 418       {
 419         ds = ds.getDatasetSequence();
 420       }
 421
 422       if (targetChainIds != null && targetChainIds[s] != null)
 423       {
 424         infChain = false;
 425         targetChainId = targetChainIds[s];
 426       }
 427       else if (seq.getName().indexOf("|") > -1)
 428       {
 429         targetChainId = seq.getName().substring(
 430                 seq.getName().lastIndexOf("|") + 1);
 431         if (targetChainId.length() > 1)
 432         {
 433           if (targetChainId.trim().length() == 0)
 434           {
 435             targetChainId = " ";
 436           }
 437           else
 438           {
 439             // not a valid chain identifier
 440             targetChainId = "";
 441           }
 442         }
 443       }
 444       else
 445       {
 446         targetChainId = "";
 447       }
 448
 449       /*
 450        * Attempt pairwise alignment of the sequence with each chain in the PDB,
 451        * and remember the highest scoring chain
 452        */
 453       int max = -10;
 454       AlignSeq maxAlignseq = null;
 455       String maxChainId = " ";
 456       PDBChain maxChain = null;
 457       boolean first = true;
 458       for (PDBChain chain : pdb.getChains())
 459       {
 460         if (targetChainId.length() > 0 && !targetChainId.equals(chain.id)
 461                 && !infChain)
 462         {
 463           continue; // don't try to map chains don't match.
 464         }
 465         // TODO: correctly determine sequence type for mixed na/peptide
 466         // structures
 467         final String type = chain.isNa ? AlignSeq.DNA : AlignSeq.PEP;
 468         AlignSeq as = AlignSeq.doGlobalNWAlignment(seq, chain.sequence,
 469                 type);
 470         // equivalent to:
 471         // AlignSeq as = new AlignSeq(sequence[s], chain.sequence, type);
 472         // as.calcScoreMatrix();
 473         // as.traceAlignment();
 474
 475         if (first || as.maxscore > max
 476                 || (as.maxscore == max && chain.id.equals(targetChainId)))
 477         {
 478           first = false;
 479           maxChain = chain;
 480           max = as.maxscore;
 481           maxAlignseq = as;
 482           maxChainId = chain.id;
 483         }
 484       }
 485       if (maxChain == null)
 486       {
 487         continue;
 488       }
 489
 490       if (protocol.equals(jalview.io.AppletFormatAdapter.PASTE))
 491       {
 492         pdbFile = "INLINE" + pdb.getId();
 493       }
 494
 495       ArrayList<StructureMapping> seqToStrucMapping = new ArrayList<StructureMapping>();
 496       if (isMapUsingSIFTs && seq.isProtein())
 497       {
 498         setProgressBar(null);
 499         setProgressBar(MessageManager
 500                 .getString("status.obtaining_mapping_with_sifts"));
 501         jalview.datamodel.Mapping sqmpping = maxAlignseq
 502                 .getMappingFromS1(false);
 503         if (targetChainId != null && !targetChainId.trim().isEmpty())
 504         {
 505           StructureMapping siftsMapping;
 506           try
 507           {
 508             siftsMapping = getStructureMapping(seq, pdbFile, targetChainId,
 509                     pdb, maxChain, sqmpping, maxAlignseq);
 510             seqToStrucMapping.add(siftsMapping);
 511             maxChain.makeExactMapping(maxAlignseq, seq);
 512             maxChain.transferRESNUMFeatures(seq, null);// FIXME: is this
 513                                                        // "IEA:SIFTS" ?
 514             maxChain.transferResidueAnnotation(siftsMapping, sqmpping);
 515             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 516
 517           } catch (SiftsException e)
 518           {
 519             // fall back to NW alignment
 520             System.err.println(e.getMessage());
 521             StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 522                     targetChainId, maxChain, pdb, maxAlignseq);
 523             seqToStrucMapping.add(nwMapping);
 524             maxChain.makeExactMapping(maxAlignseq, seq);
 525             maxChain.transferRESNUMFeatures(seq, null); // FIXME: is this
 526                                                         // "IEA:Jalview" ?
 527             maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 528             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 529           }
 530         }
 531         else
 532         {
 533           ArrayList<StructureMapping> foundSiftsMappings = new ArrayList<StructureMapping>();
 534           for (PDBChain chain : pdb.getChains())
 535           {
 536             try
 537             {
 538               StructureMapping siftsMapping = getStructureMapping(seq,
 539                       pdbFile, chain.id, pdb, chain, sqmpping, maxAlignseq);
 540               foundSiftsMappings.add(siftsMapping);
 541             } catch (SiftsException e)
 542             {
 543               System.err.println(e.getMessage());
 544             }
 545           }
 546           if (!foundSiftsMappings.isEmpty())
 547           {
 548             seqToStrucMapping.addAll(foundSiftsMappings);
 549             maxChain.makeExactMapping(maxAlignseq, seq);
 550             maxChain.transferRESNUMFeatures(seq, null);// FIXME: is this
 551                                                        // "IEA:SIFTS" ?
 552             maxChain.transferResidueAnnotation(foundSiftsMappings.get(0),
 553                     sqmpping);
 554             ds.addPDBId(sqmpping.getTo().getAllPDBEntries().get(0));
 555           }
 556           else
 557           {
 558             StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 559                     maxChainId, maxChain, pdb, maxAlignseq);
 560             seqToStrucMapping.add(nwMapping);
 561             maxChain.transferRESNUMFeatures(seq, null); // FIXME: is this
 562                                                         // "IEA:Jalview" ?
 563             maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 564             ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 565           }
 566         }
 567       }
 568       else
 569       {
 570         setProgressBar(null);
 571         setProgressBar(MessageManager
 572                 .getString("status.obtaining_mapping_with_nw_alignment"));
 573         StructureMapping nwMapping = getNWMappings(seq, pdbFile,
 574                 maxChainId, maxChain, pdb, maxAlignseq);
 575         seqToStrucMapping.add(nwMapping);
 576         ds.addPDBId(maxChain.sequence.getAllPDBEntries().get(0));
 577
 578       }
 579
 580       if (forStructureView)
 581       {
 582         mappings.addAll(seqToStrucMapping);
 583       }
 584     }
 585     return pdb;
 586   }
 587
 588   private boolean isCIFFile(String filename)
 589   {
 590     String fileExt = filename.substring(filename.lastIndexOf(".") + 1,
 591             filename.length());
 592     return "cif".equalsIgnoreCase(fileExt);
 593   }
 594
 595   /**
 596    * retrieve a mapping for seq from SIFTs using associated DBRefEntry for
 597    * uniprot or PDB
 598    *
 599    * @param seq
 600    * @param pdbFile
 601    * @param targetChainId
 602    * @param pdb
 603    * @param maxChain
 604    * @param sqmpping
 605    * @param maxAlignseq
 606    * @return
 607    * @throws SiftsException
 608    */
 609   private StructureMapping getStructureMapping(SequenceI seq,
 610           String pdbFile, String targetChainId, StructureFile pdb,
 611           PDBChain maxChain, jalview.datamodel.Mapping sqmpping,
 612           AlignSeq maxAlignseq) throws SiftsException
 613   {
 614     StructureMapping curChainMapping = siftsClient
 615             .getSiftsStructureMapping(seq, pdbFile, targetChainId);
 616     try
 617     {
 618       PDBChain chain = pdb.findChain(targetChainId);
 619       if (chain != null)
 620       {
 621         chain.transferResidueAnnotation(curChainMapping, sqmpping);
 622       }
 623     } catch (Exception e)
 624     {
 625       e.printStackTrace();
 626     }
 627     return curChainMapping;
 628   }
 629
 630   private StructureMapping getNWMappings(SequenceI seq, String pdbFile,
 631           String maxChainId, PDBChain maxChain, StructureFile pdb,
 632           AlignSeq maxAlignseq)
 633   {
 634     final StringBuilder mappingDetails = new StringBuilder(128);
 635     mappingDetails.append(NEWLINE).append(
 636             "Sequence \u27f7 Structure mapping details");
 637     mappingDetails.append(NEWLINE);
 638     mappingDetails
 639             .append("Method: inferred with Needleman & Wunsch alignment");
 640     mappingDetails.append(NEWLINE).append("PDB Sequence is :")
 641             .append(NEWLINE).append("Sequence = ")
 642             .append(maxChain.sequence.getSequenceAsString());
 643     mappingDetails.append(NEWLINE).append("No of residues = ")
 644             .append(maxChain.residues.size()).append(NEWLINE)
 645             .append(NEWLINE);
 646     PrintStream ps = new PrintStream(System.out)
 647     {
 648       @Override
 649       public void print(String x)
 650       {
 651         mappingDetails.append(x);
 652       }
 653
 654       @Override
 655       public void println()
 656       {
 657         mappingDetails.append(NEWLINE);
 658       }
 659     };
 660
 661     maxAlignseq.printAlignment(ps);
 662
 663     mappingDetails.append(NEWLINE).append("PDB start/end ");
 664     mappingDetails.append(String.valueOf(maxAlignseq.seq2start))
 665             .append(" ");
 666     mappingDetails.append(String.valueOf(maxAlignseq.seq2end));
 667     mappingDetails.append(NEWLINE).append("SEQ start/end ");
 668     mappingDetails.append(
 669             String.valueOf(maxAlignseq.seq1start + (seq.getStart() - 1)))
 670             .append(" ");
 671     mappingDetails.append(String.valueOf(maxAlignseq.seq1end
 672             + (seq.getStart() - 1)));
 673     mappingDetails.append(NEWLINE);
 674     maxChain.makeExactMapping(maxAlignseq, seq);
 675     jalview.datamodel.Mapping sqmpping = maxAlignseq
 676             .getMappingFromS1(false);
 677     maxChain.transferRESNUMFeatures(seq, null);
 678
 679     HashMap<Integer, int[]> mapping = new HashMap<Integer, int[]>();
 680     int resNum = -10000;
 681     int index = 0;
 682     char insCode = ' ';
 683
 684     do
 685     {
 686       Atom tmp = maxChain.atoms.elementAt(index);
 687       if ((resNum != tmp.resNumber || insCode != tmp.insCode)
 688               && tmp.alignmentMapping != -1)
 689       {
 690         resNum = tmp.resNumber;
 691         insCode = tmp.insCode;
 692         if (tmp.alignmentMapping >= -1)
 693         {
 694           mapping.put(tmp.alignmentMapping + 1, new int[] { tmp.resNumber,
 695               tmp.atomIndex });
 696         }
 697       }
 698
 699       index++;
 700     } while (index < maxChain.atoms.size());
 701
 702     StructureMapping nwMapping = new StructureMapping(seq, pdbFile,
 703             pdb.getId(), maxChainId, mapping, mappingDetails.toString());
 704     maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 705     return nwMapping;
 706   }
 707
 708   public void removeStructureViewerListener(Object svl, String[] pdbfiles)
 709   {
 710     listeners.removeElement(svl);
 711     if (svl instanceof SequenceListener)
 712     {
 713       for (int i = 0; i < listeners.size(); i++)
 714       {
 715         if (listeners.elementAt(i) instanceof StructureListener)
 716         {
 717           ((StructureListener) listeners.elementAt(i))
 718                   .releaseReferences(svl);
 719         }
 720       }
 721     }
 722
 723     if (pdbfiles == null)
 724     {
 725       return;
 726     }
 727
 728     /*
 729      * Remove mappings to the closed listener's PDB files, but first check if
 730      * another listener is still interested
 731      */
 732     List<String> pdbs = new ArrayList<String>(Arrays.asList(pdbfiles));
 733
 734     StructureListener sl;
 735     for (int i = 0; i < listeners.size(); i++)
 736     {
 737       if (listeners.elementAt(i) instanceof StructureListener)
 738       {
 739         sl = (StructureListener) listeners.elementAt(i);
 740         for (String pdbfile : sl.getPdbFile())
 741         {
 742           pdbs.remove(pdbfile);
 743         }
 744       }
 745     }
 746
 747     /*
 748      * Rebuild the mappings set, retaining only those which are for 'other' PDB
 749      * files
 750      */
 751     if (pdbs.size() > 0)
 752     {
 753       List<StructureMapping> tmp = new ArrayList<StructureMapping>();
 754       for (StructureMapping sm : mappings)
 755       {
 756         if (!pdbs.contains(sm.pdbfile))
 757         {
 758           tmp.add(sm);
 759         }
 760       }
 761
 762       mappings = tmp;
 763     }
 764   }
 765
 766   /**
 767    * Propagate mouseover of a single position in a structure
 768    *
 769    * @param pdbResNum
 770    * @param chain
 771    * @param pdbfile
 772    */
 773   public void mouseOverStructure(int pdbResNum, String chain, String pdbfile)
 774   {
 775     AtomSpec atomSpec = new AtomSpec(pdbfile, chain, pdbResNum, 0);
 776     List<AtomSpec> atoms = Collections.singletonList(atomSpec);
 777     mouseOverStructure(atoms);
 778   }
 779
 780   /**
 781    * Propagate mouseover or selection of multiple positions in a structure
 782    *
 783    * @param atoms
 784    */
 785   public void mouseOverStructure(List<AtomSpec> atoms)
 786   {
 787     if (listeners == null)
 788     {
 789       // old or prematurely sent event
 790       return;
 791     }
 792     boolean hasSequenceListener = false;
 793     for (int i = 0; i < listeners.size(); i++)
 794     {
 795       if (listeners.elementAt(i) instanceof SequenceListener)
 796       {
 797         hasSequenceListener = true;
 798       }
 799     }
 800     if (!hasSequenceListener)
 801     {
 802       return;
 803     }
 804
 805     SearchResults results = new SearchResults();
 806     for (AtomSpec atom : atoms)
 807     {
 808       SequenceI lastseq = null;
 809       int lastipos = -1;
 810       for (StructureMapping sm : mappings)
 811       {
 812         if (sm.pdbfile.equals(atom.getPdbFile())
 813                 && sm.pdbchain.equals(atom.getChain()))
 814         {
 815           int indexpos = sm.getSeqPos(atom.getPdbResNum());
 816           if (lastipos != indexpos && lastseq != sm.sequence)
 817           {
 818             results.addResult(sm.sequence, indexpos, indexpos);
 819             lastipos = indexpos;
 820             lastseq = sm.sequence;
 821             // construct highlighted sequence list
 822             for (AlignedCodonFrame acf : seqmappings)
 823             {
 824               acf.markMappedRegion(sm.sequence, indexpos, results);
 825             }
 826           }
 827         }
 828       }
 829     }
 830     for (Object li : listeners)
 831     {
 832       if (li instanceof SequenceListener)
 833       {
 834         ((SequenceListener) li).highlightSequence(results);
 835       }
 836     }
 837   }
 838
 839   /**
 840    * highlight regions associated with a position (indexpos) in seq
 841    *
 842    * @param seq
 843    *          the sequence that the mouse over occurred on
 844    * @param indexpos
 845    *          the absolute position being mouseovered in seq (0 to seq.length())
 846    * @param seqPos
 847    *          the sequence position (if -1, seq.findPosition is called to
 848    *          resolve the residue number)
 849    */
 850   public void mouseOverSequence(SequenceI seq, int indexpos, int seqPos,
 851           VamsasSource source)
 852   {
 853     boolean hasSequenceListeners = handlingVamsasMo
 854             || !seqmappings.isEmpty();
 855     SearchResults results = null;
 856     if (seqPos == -1)
 857     {
 858       seqPos = seq.findPosition(indexpos);
 859     }
 860     for (int i = 0; i < listeners.size(); i++)
 861     {
 862       Object listener = listeners.elementAt(i);
 863       if (listener == source)
 864       {
 865         // TODO listener (e.g. SeqPanel) is never == source (AlignViewport)
 866         // Temporary fudge with SequenceListener.getVamsasSource()
 867         continue;
 868       }
 869       if (listener instanceof StructureListener)
 870       {
 871         highlightStructure((StructureListener) listener, seq, seqPos);
 872       }
 873       else
 874       {
 875         if (listener instanceof SequenceListener)
 876         {
 877           final SequenceListener seqListener = (SequenceListener) listener;
 878           if (hasSequenceListeners
 879                   && seqListener.getVamsasSource() != source)
 880           {
 881             if (relaySeqMappings)
 882             {
 883               if (results == null)
 884               {
 885                 results = MappingUtils.buildSearchResults(seq, seqPos,
 886                         seqmappings);
 887               }
 888               if (handlingVamsasMo)
 889               {
 890                 results.addResult(seq, seqPos, seqPos);
 891
 892               }
 893               if (!results.isEmpty())
 894               {
 895                 seqListener.highlightSequence(results);
 896               }
 897             }
 898           }
 899         }
 900         else if (listener instanceof VamsasListener && !handlingVamsasMo)
 901         {
 902           ((VamsasListener) listener).mouseOverSequence(seq, indexpos,
 903                   source);
 904         }
 905         else if (listener instanceof SecondaryStructureListener)
 906         {
 907           ((SecondaryStructureListener) listener).mouseOverSequence(seq,
 908                   indexpos, seqPos);
 909         }
 910       }
 911     }
 912   }
 913
 914   /**
 915    * Send suitable messages to a StructureListener to highlight atoms
 916    * corresponding to the given sequence position(s)
 917    *
 918    * @param sl
 919    * @param seq
 920    * @param positions
 921    */
 922   public void highlightStructure(StructureListener sl, SequenceI seq,
 923           int... positions)
 924   {
 925     if (!sl.isListeningFor(seq))
 926     {
 927       return;
 928     }
 929     int atomNo;
 930     List<AtomSpec> atoms = new ArrayList<AtomSpec>();
 931     for (StructureMapping sm : mappings)
 932     {
 933       if (sm.sequence == seq
 934               || sm.sequence == seq.getDatasetSequence()
 935               || (sm.sequence.getDatasetSequence() != null && sm.sequence
 936                       .getDatasetSequence() == seq.getDatasetSequence()))
 937       {
 938         for (int index : positions)
 939         {
 940           atomNo = sm.getAtomNum(index);
 941
 942           if (atomNo > 0)
 943           {
 944             atoms.add(new AtomSpec(sm.pdbfile, sm.pdbchain, sm
 945                     .getPDBResNum(index), atomNo));
 946           }
 947         }
 948       }
 949     }
 950     sl.highlightAtoms(atoms);
 951   }
 952
 953   /**
 954    * true if a mouse over event from an external (ie Vamsas) source is being
 955    * handled
 956    */
 957   boolean handlingVamsasMo = false;
 958
 959   long lastmsg = 0;
 960
 961   /**
 962    * as mouseOverSequence but only route event to SequenceListeners
 963    *
 964    * @param sequenceI
 965    * @param position
 966    *          in an alignment sequence
 967    */
 968   public void mouseOverVamsasSequence(SequenceI sequenceI, int position,
 969           VamsasSource source)
 970   {
 971     handlingVamsasMo = true;
 972     long msg = sequenceI.hashCode() * (1 + position);
 973     if (lastmsg != msg)
 974     {
 975       lastmsg = msg;
 976       mouseOverSequence(sequenceI, position, -1, source);
 977     }
 978     handlingVamsasMo = false;
 979   }
 980
 981   public Annotation[] colourSequenceFromStructure(SequenceI seq,
 982           String pdbid)
 983   {
 984     return null;
 985     // THIS WILL NOT BE AVAILABLE IN JALVIEW 2.3,
 986     // UNTIL THE COLOUR BY ANNOTATION IS REWORKED
 987     /*
 988      * Annotation [] annotations = new Annotation[seq.getLength()];
 989      *
 990      * StructureListener sl; int atomNo = 0; for (int i = 0; i <
 991      * listeners.size(); i++) { if (listeners.elementAt(i) instanceof
 992      * StructureListener) { sl = (StructureListener) listeners.elementAt(i);
 993      *
 994      * for (int j = 0; j < mappings.length; j++) {
 995      *
 996      * if (mappings[j].sequence == seq && mappings[j].getPdbId().equals(pdbid)
 997      * && mappings[j].pdbfile.equals(sl.getPdbFile())) {
 998      * System.out.println(pdbid+" "+mappings[j].getPdbId() +"
 999      * "+mappings[j].pdbfile);
1000      *
1001      * java.awt.Color col; for(int index=0; index<seq.getLength(); index++) {
1002      * if(jalview.util.Comparison.isGap(seq.getCharAt(index))) continue;
1003      *
1004      * atomNo = mappings[j].getAtomNum(seq.findPosition(index)); col =
1005      * java.awt.Color.white; if (atomNo > 0) { col = sl.getColour(atomNo,
1006      * mappings[j].getPDBResNum(index), mappings[j].pdbchain,
1007      * mappings[j].pdbfile); }
1008      *
1009      * annotations[index] = new Annotation("X",null,' ',0,col); } return
1010      * annotations; } } } }
1011      *
1012      * return annotations;
1013      */
1014   }
1015
1016   public void structureSelectionChanged()
1017   {
1018   }
1019
1020   public void sequenceSelectionChanged()
1021   {
1022   }
1023
1024   public void sequenceColoursChanged(Object source)
1025   {
1026     StructureListener sl;
1027     for (int i = 0; i < listeners.size(); i++)
1028     {
1029       if (listeners.elementAt(i) instanceof StructureListener)
1030       {
1031         sl = (StructureListener) listeners.elementAt(i);
1032         sl.updateColours(source);
1033       }
1034     }
1035   }
1036
1037   public StructureMapping[] getMapping(String pdbfile)
1038   {
1039     List<StructureMapping> tmp = new ArrayList<StructureMapping>();
1040     for (StructureMapping sm : mappings)
1041     {
1042       if (sm.pdbfile.equals(pdbfile))
1043       {
1044         tmp.add(sm);
1045       }
1046     }
1047     return tmp.toArray(new StructureMapping[tmp.size()]);
1048   }
1049
1050   /**
1051    * Returns a readable description of all mappings for the given pdbfile to any
1052    * of the given sequences
1053    *
1054    * @param pdbfile
1055    * @param seqs
1056    * @return
1057    */
1058   public String printMappings(String pdbfile, List<SequenceI> seqs)
1059   {
1060     if (pdbfile == null || seqs == null || seqs.isEmpty())
1061     {
1062       return "";
1063     }
1064
1065     StringBuilder sb = new StringBuilder(64);
1066     for (StructureMapping sm : mappings)
1067     {
1068       if (sm.pdbfile.equals(pdbfile) && seqs.contains(sm.sequence))
1069       {
1070         sb.append(sm.mappingDetails);
1071         sb.append(NEWLINE);
1072         // separator makes it easier to read multiple mappings
1073         sb.append("=====================");
1074         sb.append(NEWLINE);
1075       }
1076     }
1077     sb.append(NEWLINE);
1078
1079     return sb.toString();
1080   }
1081
1082   /**
1083    * Remove the given mapping
1084    *
1085    * @param acf
1086    */
1087   public void deregisterMapping(AlignedCodonFrame acf)
1088   {
1089     if (acf != null)
1090     {
1091       boolean removed = seqmappings.remove(acf);
1092       if (removed && seqmappings.isEmpty())
1093       { // debug
1094         System.out.println("All mappings removed");
1095       }
1096     }
1097   }
1098
1099   /**
1100    * Add each of the given codonFrames to the stored set, if not aready present.
1101    *
1102    * @param mappings
1103    */
1104   public void registerMappings(List<AlignedCodonFrame> mappings)
1105   {
1106     if (mappings != null)
1107     {
1108       for (AlignedCodonFrame acf : mappings)
1109       {
1110         registerMapping(acf);
1111       }
1112     }
1113   }
1114
1115   /**
1116    * Add the given mapping to the stored set, unless already stored.
1117    */
1118   public void registerMapping(AlignedCodonFrame acf)
1119   {
1120     if (acf != null)
1121     {
1122       if (!seqmappings.contains(acf))
1123       {
1124         seqmappings.add(acf);
1125       }
1126     }
1127   }
1128
1129   /**
1130    * Resets this object to its initial state by removing all registered
1131    * listeners, codon mappings, PDB file mappings
1132    */
1133   public void resetAll()
1134   {
1135     if (mappings != null)
1136     {
1137       mappings.clear();
1138     }
1139     if (seqmappings != null)
1140     {
1141       seqmappings.clear();
1142     }
1143     if (sel_listeners != null)
1144     {
1145       sel_listeners.clear();
1146     }
1147     if (listeners != null)
1148     {
1149       listeners.clear();
1150     }
1151     if (commandListeners != null)
1152     {
1153       commandListeners.clear();
1154     }
1155     if (view_listeners != null)
1156     {
1157       view_listeners.clear();
1158     }
1159     if (pdbFileNameId != null)
1160     {
1161       pdbFileNameId.clear();
1162     }
1163     if (pdbIdFileName != null)
1164     {
1165       pdbIdFileName.clear();
1166     }
1167   }
1168
1169   public void addSelectionListener(SelectionListener selecter)
1170   {
1171     if (!sel_listeners.contains(selecter))
1172     {
1173       sel_listeners.add(selecter);
1174     }
1175   }
1176
1177   public void removeSelectionListener(SelectionListener toremove)
1178   {
1179     if (sel_listeners.contains(toremove))
1180     {
1181       sel_listeners.remove(toremove);
1182     }
1183   }
1184
1185   public synchronized void sendSelection(
1186           jalview.datamodel.SequenceGroup selection,
1187           jalview.datamodel.ColumnSelection colsel, SelectionSource source)
1188   {
1189     for (SelectionListener slis : sel_listeners)
1190     {
1191       if (slis != source)
1192       {
1193         slis.selection(selection, colsel, source);
1194       }
1195     }
1196   }
1197
1198   Vector<AlignmentViewPanelListener> view_listeners = new Vector<AlignmentViewPanelListener>();
1199
1200   public synchronized void sendViewPosition(
1201           jalview.api.AlignmentViewPanel source, int startRes, int endRes,
1202           int startSeq, int endSeq)
1203   {
1204
1205     if (view_listeners != null && view_listeners.size() > 0)
1206     {
1207       Enumeration<AlignmentViewPanelListener> listeners = view_listeners
1208               .elements();
1209       while (listeners.hasMoreElements())
1210       {
1211         AlignmentViewPanelListener slis = listeners.nextElement();
1212         if (slis != source)
1213         {
1214           slis.viewPosition(startRes, endRes, startSeq, endSeq, source);
1215         }
1216         ;
1217       }
1218     }
1219   }
1220
1221   /**
1222    * release all references associated with this manager provider
1223    *
1224    * @param jalviewLite
1225    */
1226   public static void release(StructureSelectionManagerProvider jalviewLite)
1227   {
1228     // synchronized (instances)
1229     {
1230       if (instances == null)
1231       {
1232         return;
1233       }
1234       StructureSelectionManager mnger = (instances.get(jalviewLite));
1235       if (mnger != null)
1236       {
1237         instances.remove(jalviewLite);
1238         try
1239         {
1240           mnger.finalize();
1241         } catch (Throwable x)
1242         {
1243         }
1244       }
1245     }
1246   }
1247
1248   public void registerPDBEntry(PDBEntry pdbentry)
1249   {
1250     if (pdbentry.getFile() != null
1251             && pdbentry.getFile().trim().length() > 0)
1252     {
1253       registerPDBFile(pdbentry.getId(), pdbentry.getFile());
1254     }
1255   }
1256
1257   public void addCommandListener(CommandListener cl)
1258   {
1259     if (!commandListeners.contains(cl))
1260     {
1261       commandListeners.add(cl);
1262     }
1263   }
1264
1265   public boolean hasCommandListener(CommandListener cl)
1266   {
1267     return this.commandListeners.contains(cl);
1268   }
1269
1270   public boolean removeCommandListener(CommandListener l)
1271   {
1272     return commandListeners.remove(l);
1273   }
1274
1275   /**
1276    * Forward a command to any command listeners (except for the command's
1277    * source).
1278    *
1279    * @param command
1280    *          the command to be broadcast (in its form after being performed)
1281    * @param undo
1282    *          if true, the command was being 'undone'
1283    * @param source
1284    */
1285   public void commandPerformed(CommandI command, boolean undo,
1286           VamsasSource source)
1287   {
1288     for (CommandListener listener : commandListeners)
1289     {
1290       listener.mirrorCommand(command, undo, this, source);
1291     }
1292   }
1293
1294   /**
1295    * Returns a new CommandI representing the given command as mapped to the
1296    * given sequences. If no mapping could be made, or the command is not of a
1297    * mappable kind, returns null.
1298    *
1299    * @param command
1300    * @param undo
1301    * @param mapTo
1302    * @param gapChar
1303    * @return
1304    */
1305   public CommandI mapCommand(CommandI command, boolean undo,
1306           final AlignmentI mapTo, char gapChar)
1307   {
1308     if (command instanceof EditCommand)
1309     {
1310       return MappingUtils.mapEditCommand((EditCommand) command, undo,
1311               mapTo, gapChar, seqmappings);
1312     }
1313     else if (command instanceof OrderCommand)
1314     {
1315       return MappingUtils.mapOrderCommand((OrderCommand) command, undo,
1316               mapTo, seqmappings);
1317     }
1318     return null;
1319   }
1320
1321   public IProgressIndicator getProgressIndicator()
1322   {
1323     return progressIndicator;
1324   }
1325
1326   public void setProgressIndicator(IProgressIndicator progressIndicator)
1327   {
1328     this.progressIndicator = progressIndicator;
1329   }
1330
1331   public long getProgressSessionId()
1332   {
1333     return progressSessionId;
1334   }
1335
1336   public void setProgressSessionId(long progressSessionId)
1337   {
1338     this.progressSessionId = progressSessionId;
1339   }
1340
1341   public void setProgressBar(String message)
1342   {
1343     if (progressIndicator == null)
1344     {
1345       return;
1346     }
1347     progressIndicator.setProgressBar(message, progressSessionId);
1348   }
1349
1350   public List<AlignedCodonFrame> getSequenceMappings()
1351   {
1352     return seqmappings;
1353   }
1354
1355 }