src/jalview/structure/StructureSelectionManager.java

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