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    * 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       // if PDB/mmCIF file is local then don't perform SIFTS MAPPING
 394       if (pdb.getId().contains("."))
 395       {
 396         isMapUsingSIFTs = false;
 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       int 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 (protocol.equals(jalview.io.AppletFormatAdapter.PASTE))
 496       {
 497         pdbFile = "INLINE" + pdb.getId();
 498       }
 499
 500       ArrayList<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           ArrayList<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   private boolean isCIFFile(String filename)
 594   {
 595     String fileExt = filename.substring(filename.lastIndexOf(".") + 1,
 596             filename.length());
 597     return "cif".equalsIgnoreCase(fileExt);
 598   }
 599
 600   /**
 601    * retrieve a mapping for seq from SIFTs using associated DBRefEntry for
 602    * uniprot or PDB
 603    *
 604    * @param seq
 605    * @param pdbFile
 606    * @param targetChainId
 607    * @param pdb
 608    * @param maxChain
 609    * @param sqmpping
 610    * @param maxAlignseq
 611    * @return
 612    * @throws SiftsException
 613    */
 614   private StructureMapping getStructureMapping(SequenceI seq,
 615           String pdbFile, String targetChainId, StructureFile pdb,
 616           PDBChain maxChain, jalview.datamodel.Mapping sqmpping,
 617           AlignSeq maxAlignseq) throws SiftsException
 618   {
 619     StructureMapping curChainMapping = siftsClient
 620             .getSiftsStructureMapping(seq, pdbFile, targetChainId);
 621     try
 622     {
 623       PDBChain chain = pdb.findChain(targetChainId);
 624       if (chain != null)
 625       {
 626         chain.transferResidueAnnotation(curChainMapping, sqmpping);
 627       }
 628     } catch (Exception e)
 629     {
 630       e.printStackTrace();
 631     }
 632     return curChainMapping;
 633   }
 634
 635   private StructureMapping getNWMappings(SequenceI seq, String pdbFile,
 636           String maxChainId, PDBChain maxChain, StructureFile pdb,
 637           AlignSeq maxAlignseq)
 638   {
 639     final StringBuilder mappingDetails = new StringBuilder(128);
 640     mappingDetails.append(NEWLINE).append(
 641             "Sequence \u27f7 Structure mapping details");
 642     mappingDetails.append(NEWLINE);
 643     mappingDetails
 644             .append("Method: inferred with Needleman & Wunsch alignment");
 645     mappingDetails.append(NEWLINE).append("PDB Sequence is :")
 646             .append(NEWLINE).append("Sequence = ")
 647             .append(maxChain.sequence.getSequenceAsString());
 648     mappingDetails.append(NEWLINE).append("No of residues = ")
 649             .append(maxChain.residues.size()).append(NEWLINE)
 650             .append(NEWLINE);
 651     PrintStream ps = new PrintStream(System.out)
 652     {
 653       @Override
 654       public void print(String x)
 655       {
 656         mappingDetails.append(x);
 657       }
 658
 659       @Override
 660       public void println()
 661       {
 662         mappingDetails.append(NEWLINE);
 663       }
 664     };
 665
 666     maxAlignseq.printAlignment(ps);
 667
 668     mappingDetails.append(NEWLINE).append("PDB start/end ");
 669     mappingDetails.append(String.valueOf(maxAlignseq.seq2start))
 670             .append(" ");
 671     mappingDetails.append(String.valueOf(maxAlignseq.seq2end));
 672     mappingDetails.append(NEWLINE).append("SEQ start/end ");
 673     mappingDetails.append(
 674             String.valueOf(maxAlignseq.seq1start + (seq.getStart() - 1)))
 675             .append(" ");
 676     mappingDetails.append(String.valueOf(maxAlignseq.seq1end
 677             + (seq.getStart() - 1)));
 678     mappingDetails.append(NEWLINE);
 679     maxChain.makeExactMapping(maxAlignseq, seq);
 680     jalview.datamodel.Mapping sqmpping = maxAlignseq
 681             .getMappingFromS1(false);
 682     maxChain.transferRESNUMFeatures(seq, null);
 683
 684     HashMap<Integer, int[]> mapping = new HashMap<Integer, int[]>();
 685     int resNum = -10000;
 686     int index = 0;
 687     char insCode = ' ';
 688
 689     do
 690     {
 691       Atom tmp = maxChain.atoms.elementAt(index);
 692       if ((resNum != tmp.resNumber || insCode != tmp.insCode)
 693               && tmp.alignmentMapping != -1)
 694       {
 695         resNum = tmp.resNumber;
 696         insCode = tmp.insCode;
 697         if (tmp.alignmentMapping >= -1)
 698         {
 699           mapping.put(tmp.alignmentMapping + 1, new int[] { tmp.resNumber,
 700               tmp.atomIndex });
 701         }
 702       }
 703
 704       index++;
 705     } while (index < maxChain.atoms.size());
 706
 707     StructureMapping nwMapping = new StructureMapping(seq, pdbFile,
 708             pdb.getId(), maxChainId, mapping, mappingDetails.toString());
 709     maxChain.transferResidueAnnotation(nwMapping, sqmpping);
 710     return nwMapping;
 711   }
 712
 713   public void removeStructureViewerListener(Object svl, String[] pdbfiles)
 714   {
 715     listeners.removeElement(svl);
 716     if (svl instanceof SequenceListener)
 717     {
 718       for (int i = 0; i < listeners.size(); i++)
 719       {
 720         if (listeners.elementAt(i) instanceof StructureListener)
 721         {
 722           ((StructureListener) listeners.elementAt(i))
 723                   .releaseReferences(svl);
 724         }
 725       }
 726     }
 727
 728     if (pdbfiles == null)
 729     {
 730       return;
 731     }
 732
 733     /*
 734      * Remove mappings to the closed listener's PDB files, but first check if
 735      * another listener is still interested
 736      */
 737     List<String> pdbs = new ArrayList<String>(Arrays.asList(pdbfiles));
 738
 739     StructureListener sl;
 740     for (int i = 0; i < listeners.size(); i++)
 741     {
 742       if (listeners.elementAt(i) instanceof StructureListener)
 743       {
 744         sl = (StructureListener) listeners.elementAt(i);
 745         for (String pdbfile : sl.getPdbFile())
 746         {
 747           pdbs.remove(pdbfile);
 748         }
 749       }
 750     }
 751
 752     /*
 753      * Rebuild the mappings set, retaining only those which are for 'other' PDB
 754      * files
 755      */
 756     if (pdbs.size() > 0)
 757     {
 758       List<StructureMapping> tmp = new ArrayList<StructureMapping>();
 759       for (StructureMapping sm : mappings)
 760       {
 761         if (!pdbs.contains(sm.pdbfile))
 762         {
 763           tmp.add(sm);
 764         }
 765       }
 766
 767       mappings = tmp;
 768     }
 769   }
 770
 771   /**
 772    * Propagate mouseover of a single position in a structure
 773    *
 774    * @param pdbResNum
 775    * @param chain
 776    * @param pdbfile
 777    */
 778   public void mouseOverStructure(int pdbResNum, String chain, String pdbfile)
 779   {
 780     AtomSpec atomSpec = new AtomSpec(pdbfile, chain, pdbResNum, 0);
 781     List<AtomSpec> atoms = Collections.singletonList(atomSpec);
 782     mouseOverStructure(atoms);
 783   }
 784
 785   /**
 786    * Propagate mouseover or selection of multiple positions in a structure
 787    *
 788    * @param atoms
 789    */
 790   public void mouseOverStructure(List<AtomSpec> atoms)
 791   {
 792     if (listeners == null)
 793     {
 794       // old or prematurely sent event
 795       return;
 796     }
 797     boolean hasSequenceListener = false;
 798     for (int i = 0; i < listeners.size(); i++)
 799     {
 800       if (listeners.elementAt(i) instanceof SequenceListener)
 801       {
 802         hasSequenceListener = true;
 803       }
 804     }
 805     if (!hasSequenceListener)
 806     {
 807       return;
 808     }
 809
 810     SearchResults results = new SearchResults();
 811     for (AtomSpec atom : atoms)
 812     {
 813       SequenceI lastseq = null;
 814       int lastipos = -1;
 815       for (StructureMapping sm : mappings)
 816       {
 817         if (sm.pdbfile.equals(atom.getPdbFile())
 818                 && sm.pdbchain.equals(atom.getChain()))
 819         {
 820           int indexpos = sm.getSeqPos(atom.getPdbResNum());
 821           if (lastipos != indexpos && lastseq != sm.sequence)
 822           {
 823             results.addResult(sm.sequence, indexpos, indexpos);
 824             lastipos = indexpos;
 825             lastseq = sm.sequence;
 826             // construct highlighted sequence list
 827             for (AlignedCodonFrame acf : seqmappings)
 828             {
 829               acf.markMappedRegion(sm.sequence, indexpos, results);
 830             }
 831           }
 832         }
 833       }
 834     }
 835     for (Object li : listeners)
 836     {
 837       if (li instanceof SequenceListener)
 838       {
 839         ((SequenceListener) li).highlightSequence(results);
 840       }
 841     }
 842   }
 843
 844   /**
 845    * highlight regions associated with a position (indexpos) in seq
 846    *
 847    * @param seq
 848    *          the sequence that the mouse over occurred on
 849    * @param indexpos
 850    *          the absolute position being mouseovered in seq (0 to seq.length())
 851    * @param seqPos
 852    *          the sequence position (if -1, seq.findPosition is called to
 853    *          resolve the residue number)
 854    */
 855   public void mouseOverSequence(SequenceI seq, int indexpos, int seqPos,
 856           VamsasSource source)
 857   {
 858     boolean hasSequenceListeners = handlingVamsasMo
 859             || !seqmappings.isEmpty();
 860     SearchResults results = null;
 861     if (seqPos == -1)
 862     {
 863       seqPos = seq.findPosition(indexpos);
 864     }
 865     for (int i = 0; i < listeners.size(); i++)
 866     {
 867       Object listener = listeners.elementAt(i);
 868       if (listener == source)
 869       {
 870         // TODO listener (e.g. SeqPanel) is never == source (AlignViewport)
 871         // Temporary fudge with SequenceListener.getVamsasSource()
 872         continue;
 873       }
 874       if (listener instanceof StructureListener)
 875       {
 876         highlightStructure((StructureListener) listener, seq, seqPos);
 877       }
 878       else
 879       {
 880         if (listener instanceof SequenceListener)
 881         {
 882           final SequenceListener seqListener = (SequenceListener) listener;
 883           if (hasSequenceListeners
 884                   && seqListener.getVamsasSource() != source)
 885           {
 886             if (relaySeqMappings)
 887             {
 888               if (results == null)
 889               {
 890                 results = MappingUtils.buildSearchResults(seq, seqPos,
 891                         seqmappings);
 892               }
 893               if (handlingVamsasMo)
 894               {
 895                 results.addResult(seq, seqPos, seqPos);
 896
 897               }
 898               if (!results.isEmpty())
 899               {
 900                 seqListener.highlightSequence(results);
 901               }
 902             }
 903           }
 904         }
 905         else if (listener instanceof VamsasListener && !handlingVamsasMo)
 906         {
 907           ((VamsasListener) listener).mouseOverSequence(seq, indexpos,
 908                   source);
 909         }
 910         else if (listener instanceof SecondaryStructureListener)
 911         {
 912           ((SecondaryStructureListener) listener).mouseOverSequence(seq,
 913                   indexpos, seqPos);
 914         }
 915       }
 916     }
 917   }
 918
 919   /**
 920    * Send suitable messages to a StructureListener to highlight atoms
 921    * corresponding to the given sequence position(s)
 922    *
 923    * @param sl
 924    * @param seq
 925    * @param positions
 926    */
 927   public void highlightStructure(StructureListener sl, SequenceI seq,
 928           int... positions)
 929   {
 930     if (!sl.isListeningFor(seq))
 931     {
 932       return;
 933     }
 934     int atomNo;
 935     List<AtomSpec> atoms = new ArrayList<AtomSpec>();
 936     for (StructureMapping sm : mappings)
 937     {
 938       if (sm.sequence == seq
 939               || sm.sequence == seq.getDatasetSequence()
 940               || (sm.sequence.getDatasetSequence() != null && sm.sequence
 941                       .getDatasetSequence() == seq.getDatasetSequence()))
 942       {
 943         for (int index : positions)
 944         {
 945           atomNo = sm.getAtomNum(index);
 946
 947           if (atomNo > 0)
 948           {
 949             atoms.add(new AtomSpec(sm.pdbfile, sm.pdbchain, sm
 950                     .getPDBResNum(index), atomNo));
 951           }
 952         }
 953       }
 954     }
 955     sl.highlightAtoms(atoms);
 956   }
 957
 958   /**
 959    * true if a mouse over event from an external (ie Vamsas) source is being
 960    * handled
 961    */
 962   boolean handlingVamsasMo = false;
 963
 964   long lastmsg = 0;
 965
 966   /**
 967    * as mouseOverSequence but only route event to SequenceListeners
 968    *
 969    * @param sequenceI
 970    * @param position
 971    *          in an alignment sequence
 972    */
 973   public void mouseOverVamsasSequence(SequenceI sequenceI, int position,
 974           VamsasSource source)
 975   {
 976     handlingVamsasMo = true;
 977     long msg = sequenceI.hashCode() * (1 + position);
 978     if (lastmsg != msg)
 979     {
 980       lastmsg = msg;
 981       mouseOverSequence(sequenceI, position, -1, source);
 982     }
 983     handlingVamsasMo = false;
 984   }
 985
 986   public Annotation[] colourSequenceFromStructure(SequenceI seq,
 987           String pdbid)
 988   {
 989     return null;
 990     // THIS WILL NOT BE AVAILABLE IN JALVIEW 2.3,
 991     // UNTIL THE COLOUR BY ANNOTATION IS REWORKED
 992     /*
 993      * Annotation [] annotations = new Annotation[seq.getLength()];
 994      *
 995      * StructureListener sl; int atomNo = 0; for (int i = 0; i <
 996      * listeners.size(); i++) { if (listeners.elementAt(i) instanceof
 997      * StructureListener) { sl = (StructureListener) listeners.elementAt(i);
 998      *
 999      * for (int j = 0; j < mappings.length; j++) {
1000      *
1001      * if (mappings[j].sequence == seq && mappings[j].getPdbId().equals(pdbid)
1002      * && mappings[j].pdbfile.equals(sl.getPdbFile())) {
1003      * System.out.println(pdbid+" "+mappings[j].getPdbId() +"
1004      * "+mappings[j].pdbfile);
1005      *
1006      * java.awt.Color col; for(int index=0; index<seq.getLength(); index++) {
1007      * if(jalview.util.Comparison.isGap(seq.getCharAt(index))) continue;
1008      *
1009      * atomNo = mappings[j].getAtomNum(seq.findPosition(index)); col =
1010      * java.awt.Color.white; if (atomNo > 0) { col = sl.getColour(atomNo,
1011      * mappings[j].getPDBResNum(index), mappings[j].pdbchain,
1012      * mappings[j].pdbfile); }
1013      *
1014      * annotations[index] = new Annotation("X",null,' ',0,col); } return
1015      * annotations; } } } }
1016      *
1017      * return annotations;
1018      */
1019   }
1020
1021   public void structureSelectionChanged()
1022   {
1023   }
1024
1025   public void sequenceSelectionChanged()
1026   {
1027   }
1028
1029   public void sequenceColoursChanged(Object source)
1030   {
1031     StructureListener sl;
1032     for (int i = 0; i < listeners.size(); i++)
1033     {
1034       if (listeners.elementAt(i) instanceof StructureListener)
1035       {
1036         sl = (StructureListener) listeners.elementAt(i);
1037         sl.updateColours(source);
1038       }
1039     }
1040   }
1041
1042   public StructureMapping[] getMapping(String pdbfile)
1043   {
1044     List<StructureMapping> tmp = new ArrayList<StructureMapping>();
1045     for (StructureMapping sm : mappings)
1046     {
1047       if (sm.pdbfile.equals(pdbfile))
1048       {
1049         tmp.add(sm);
1050       }
1051     }
1052     return tmp.toArray(new StructureMapping[tmp.size()]);
1053   }
1054
1055   /**
1056    * Returns a readable description of all mappings for the given pdbfile to any
1057    * of the given sequences
1058    *
1059    * @param pdbfile
1060    * @param seqs
1061    * @return
1062    */
1063   public String printMappings(String pdbfile, List<SequenceI> seqs)
1064   {
1065     if (pdbfile == null || seqs == null || seqs.isEmpty())
1066     {
1067       return "";
1068     }
1069
1070     StringBuilder sb = new StringBuilder(64);
1071     for (StructureMapping sm : mappings)
1072     {
1073       if (sm.pdbfile.equals(pdbfile) && seqs.contains(sm.sequence))
1074       {
1075         sb.append(sm.mappingDetails);
1076         sb.append(NEWLINE);
1077         // separator makes it easier to read multiple mappings
1078         sb.append("=====================");
1079         sb.append(NEWLINE);
1080       }
1081     }
1082     sb.append(NEWLINE);
1083
1084     return sb.toString();
1085   }
1086
1087   /**
1088    * Remove the given mapping
1089    *
1090    * @param acf
1091    */
1092   public void deregisterMapping(AlignedCodonFrame acf)
1093   {
1094     if (acf != null)
1095     {
1096       boolean removed = seqmappings.remove(acf);
1097       if (removed && seqmappings.isEmpty())
1098       { // debug
1099         System.out.println("All mappings removed");
1100       }
1101     }
1102   }
1103
1104   /**
1105    * Add each of the given codonFrames to the stored set, if not aready present.
1106    *
1107    * @param mappings
1108    */
1109   public void registerMappings(List<AlignedCodonFrame> mappings)
1110   {
1111     if (mappings != null)
1112     {
1113       for (AlignedCodonFrame acf : mappings)
1114       {
1115         registerMapping(acf);
1116       }
1117     }
1118   }
1119
1120   /**
1121    * Add the given mapping to the stored set, unless already stored.
1122    */
1123   public void registerMapping(AlignedCodonFrame acf)
1124   {
1125     if (acf != null)
1126     {
1127       if (!seqmappings.contains(acf))
1128       {
1129         seqmappings.add(acf);
1130       }
1131     }
1132   }
1133
1134   /**
1135    * Resets this object to its initial state by removing all registered
1136    * listeners, codon mappings, PDB file mappings
1137    */
1138   public void resetAll()
1139   {
1140     if (mappings != null)
1141     {
1142       mappings.clear();
1143     }
1144     if (seqmappings != null)
1145     {
1146       seqmappings.clear();
1147     }
1148     if (sel_listeners != null)
1149     {
1150       sel_listeners.clear();
1151     }
1152     if (listeners != null)
1153     {
1154       listeners.clear();
1155     }
1156     if (commandListeners != null)
1157     {
1158       commandListeners.clear();
1159     }
1160     if (view_listeners != null)
1161     {
1162       view_listeners.clear();
1163     }
1164     if (pdbFileNameId != null)
1165     {
1166       pdbFileNameId.clear();
1167     }
1168     if (pdbIdFileName != null)
1169     {
1170       pdbIdFileName.clear();
1171     }
1172   }
1173
1174   public void addSelectionListener(SelectionListener selecter)
1175   {
1176     if (!sel_listeners.contains(selecter))
1177     {
1178       sel_listeners.add(selecter);
1179     }
1180   }
1181
1182   public void removeSelectionListener(SelectionListener toremove)
1183   {
1184     if (sel_listeners.contains(toremove))
1185     {
1186       sel_listeners.remove(toremove);
1187     }
1188   }
1189
1190   public synchronized void sendSelection(
1191           jalview.datamodel.SequenceGroup selection,
1192           jalview.datamodel.ColumnSelection colsel, SelectionSource source)
1193   {
1194     for (SelectionListener slis : sel_listeners)
1195     {
1196       if (slis != source)
1197       {
1198         slis.selection(selection, colsel, source);
1199       }
1200     }
1201   }
1202
1203   Vector<AlignmentViewPanelListener> view_listeners = new Vector<AlignmentViewPanelListener>();
1204
1205   public synchronized void sendViewPosition(
1206           jalview.api.AlignmentViewPanel source, int startRes, int endRes,
1207           int startSeq, int endSeq)
1208   {
1209
1210     if (view_listeners != null && view_listeners.size() > 0)
1211     {
1212       Enumeration<AlignmentViewPanelListener> listeners = view_listeners
1213               .elements();
1214       while (listeners.hasMoreElements())
1215       {
1216         AlignmentViewPanelListener slis = listeners.nextElement();
1217         if (slis != source)
1218         {
1219           slis.viewPosition(startRes, endRes, startSeq, endSeq, source);
1220         }
1221         ;
1222       }
1223     }
1224   }
1225
1226   /**
1227    * release all references associated with this manager provider
1228    *
1229    * @param jalviewLite
1230    */
1231   public static void release(StructureSelectionManagerProvider jalviewLite)
1232   {
1233     // synchronized (instances)
1234     {
1235       if (instances == null)
1236       {
1237         return;
1238       }
1239       StructureSelectionManager mnger = (instances.get(jalviewLite));
1240       if (mnger != null)
1241       {
1242         instances.remove(jalviewLite);
1243         try
1244         {
1245           mnger.finalize();
1246         } catch (Throwable x)
1247         {
1248         }
1249       }
1250     }
1251   }
1252
1253   public void registerPDBEntry(PDBEntry pdbentry)
1254   {
1255     if (pdbentry.getFile() != null
1256             && pdbentry.getFile().trim().length() > 0)
1257     {
1258       registerPDBFile(pdbentry.getId(), pdbentry.getFile());
1259     }
1260   }
1261
1262   public void addCommandListener(CommandListener cl)
1263   {
1264     if (!commandListeners.contains(cl))
1265     {
1266       commandListeners.add(cl);
1267     }
1268   }
1269
1270   public boolean hasCommandListener(CommandListener cl)
1271   {
1272     return this.commandListeners.contains(cl);
1273   }
1274
1275   public boolean removeCommandListener(CommandListener l)
1276   {
1277     return commandListeners.remove(l);
1278   }
1279
1280   /**
1281    * Forward a command to any command listeners (except for the command's
1282    * source).
1283    *
1284    * @param command
1285    *          the command to be broadcast (in its form after being performed)
1286    * @param undo
1287    *          if true, the command was being 'undone'
1288    * @param source
1289    */
1290   public void commandPerformed(CommandI command, boolean undo,
1291           VamsasSource source)
1292   {
1293     for (CommandListener listener : commandListeners)
1294     {
1295       listener.mirrorCommand(command, undo, this, source);
1296     }
1297   }
1298
1299   /**
1300    * Returns a new CommandI representing the given command as mapped to the
1301    * given sequences. If no mapping could be made, or the command is not of a
1302    * mappable kind, returns null.
1303    *
1304    * @param command
1305    * @param undo
1306    * @param mapTo
1307    * @param gapChar
1308    * @return
1309    */
1310   public CommandI mapCommand(CommandI command, boolean undo,
1311           final AlignmentI mapTo, char gapChar)
1312   {
1313     if (command instanceof EditCommand)
1314     {
1315       return MappingUtils.mapEditCommand((EditCommand) command, undo,
1316               mapTo, gapChar, seqmappings);
1317     }
1318     else if (command instanceof OrderCommand)
1319     {
1320       return MappingUtils.mapOrderCommand((OrderCommand) command, undo,
1321               mapTo, seqmappings);
1322     }
1323     return null;
1324   }
1325
1326   public IProgressIndicator getProgressIndicator()
1327   {
1328     return progressIndicator;
1329   }
1330
1331   public void setProgressIndicator(IProgressIndicator progressIndicator)
1332   {
1333     this.progressIndicator = progressIndicator;
1334   }
1335
1336   public long getProgressSessionId()
1337   {
1338     return progressSessionId;
1339   }
1340
1341   public void setProgressSessionId(long progressSessionId)
1342   {
1343     this.progressSessionId = progressSessionId;
1344   }
1345
1346   public void setProgressBar(String message)
1347   {
1348     if (progressIndicator == null)
1349     {
1350       return;
1351     }
1352     progressIndicator.setProgressBar(message, progressSessionId);
1353   }
1354
1355   public List<AlignedCodonFrame> getSequenceMappings()
1356   {
1357     return seqmappings;
1358   }
1359
1360 }