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