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