src/jalview/structure/StructureSelectionManager.java

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