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