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.AlignmentViewPanel;
  25 import jalview.api.StructureSelectionManagerProvider;
  26 import jalview.commands.CommandI;
  27 import jalview.commands.EditCommand;
  28 import jalview.commands.OrderCommand;
  29 import jalview.datamodel.AlignedCodonFrame;
  30 import jalview.datamodel.AlignmentAnnotation;
  31 import jalview.datamodel.AlignmentI;
  32 import jalview.datamodel.Annotation;
  33 import jalview.datamodel.ColumnSelection;
  34 import jalview.datamodel.Mapping;
  35 import jalview.datamodel.PDBEntry;
  36 import jalview.datamodel.SearchResults;
  37 import jalview.datamodel.SequenceGroup;
  38 import jalview.datamodel.SequenceI;
  39 import jalview.io.AppletFormatAdapter;
  40 import jalview.util.MappingUtils;
  41 import jalview.util.MessageManager;
  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.LinkedHashSet;
  51 import java.util.List;
  52 import java.util.Map;
  53 import java.util.Set;
  54 import java.util.Vector;
  55
  56 import MCview.Atom;
  57 import MCview.PDBChain;
  58 import MCview.PDBfile;
  59
  60 public class StructureSelectionManager
  61 {
  62   public final static String NEWLINE = System.lineSeparator();
  63
  64   static IdentityHashMap<StructureSelectionManagerProvider, StructureSelectionManager> instances;
  65
  66   private List<StructureMapping> mappings = new ArrayList<StructureMapping>();
  67
  68   private boolean processSecondaryStructure = false;
  69
  70   private boolean secStructServices = false;
  71
  72   private boolean addTempFacAnnot = false;
  73
  74   /*
  75    * Set of any registered mappings between (dataset) sequences.
  76    */
  77   Set<AlignedCodonFrame> seqmappings = new LinkedHashSet<AlignedCodonFrame>();
  78
  79   /*
  80    * Reference counters for the above mappings. Remove mappings when ref count
  81    * goes to zero.
  82    */
  83   Map<AlignedCodonFrame, Integer> seqMappingRefCounts = new HashMap<AlignedCodonFrame, Integer>();
  84
  85   private List<CommandListener> commandListeners = new ArrayList<CommandListener>();
  86
  87   private List<SelectionListener> sel_listeners = new ArrayList<SelectionListener>();
  88
  89   /**
  90    * @return true if will try to use external services for processing secondary
  91    *         structure
  92    */
  93   public boolean isSecStructServices()
  94   {
  95     return secStructServices;
  96   }
  97
  98   /**
  99    * control use of external services for processing secondary structure
 100    *
 101    * @param secStructServices
 102    */
 103   public void setSecStructServices(boolean secStructServices)
 104   {
 105     this.secStructServices = secStructServices;
 106   }
 107
 108   /**
 109    * flag controlling addition of any kind of structural annotation
 110    *
 111    * @return true if temperature factor annotation will be added
 112    */
 113   public boolean isAddTempFacAnnot()
 114   {
 115     return addTempFacAnnot;
 116   }
 117
 118   /**
 119    * set flag controlling addition of structural annotation
 120    *
 121    * @param addTempFacAnnot
 122    */
 123   public void setAddTempFacAnnot(boolean addTempFacAnnot)
 124   {
 125     this.addTempFacAnnot = addTempFacAnnot;
 126   }
 127
 128   /**
 129    *
 130    * @return if true, the structure manager will attempt to add secondary
 131    *         structure lines for unannotated sequences
 132    */
 133
 134   public boolean isProcessSecondaryStructure()
 135   {
 136     return processSecondaryStructure;
 137   }
 138
 139   /**
 140    * Control whether structure manager will try to annotate mapped sequences
 141    * with secondary structure from PDB data.
 142    *
 143    * @param enable
 144    */
 145   public void setProcessSecondaryStructure(boolean enable)
 146   {
 147     processSecondaryStructure = enable;
 148   }
 149
 150   /**
 151    * debug function - write all mappings to stdout
 152    */
 153   public void reportMapping()
 154   {
 155     if (mappings.isEmpty())
 156     {
 157       System.err.println("reportMapping: No PDB/Sequence mappings.");
 158     }
 159     else
 160     {
 161       System.err.println("reportMapping: There are " + mappings.size()
 162               + " mappings.");
 163       int i = 0;
 164       for (StructureMapping sm : mappings)
 165       {
 166         System.err.println("mapping " + i++ + " : " + sm.pdbfile);
 167       }
 168     }
 169   }
 170
 171   /**
 172    * map between the PDB IDs (or structure identifiers) used by Jalview and the
 173    * absolute filenames for PDB data that corresponds to it
 174    */
 175   Map<String, String> pdbIdFileName = new HashMap<String, String>();
 176
 177   Map<String, String> pdbFileNameId = new HashMap<String, String>();
 178
 179   public void registerPDBFile(String idForFile, String absoluteFile)
 180   {
 181     pdbIdFileName.put(idForFile, absoluteFile);
 182     pdbFileNameId.put(absoluteFile, idForFile);
 183   }
 184
 185   public String findIdForPDBFile(String idOrFile)
 186   {
 187     String id = pdbFileNameId.get(idOrFile);
 188     return id;
 189   }
 190
 191   public String findFileForPDBId(String idOrFile)
 192   {
 193     String id = pdbIdFileName.get(idOrFile);
 194     return id;
 195   }
 196
 197   public boolean isPDBFileRegistered(String idOrFile)
 198   {
 199     return pdbFileNameId.containsKey(idOrFile)
 200             || pdbIdFileName.containsKey(idOrFile);
 201   }
 202
 203   private static StructureSelectionManager nullProvider = null;
 204
 205   public static StructureSelectionManager getStructureSelectionManager(
 206           StructureSelectionManagerProvider context)
 207   {
 208     if (context == null)
 209     {
 210       if (nullProvider == null)
 211       {
 212         if (instances != null)
 213         {
 214           throw new Error(
 215                   MessageManager
 216                           .getString("error.implementation_error_structure_selection_manager_null"),
 217                   new NullPointerException(MessageManager
 218                           .getString("exception.ssm_context_is_null")));
 219         }
 220         else
 221         {
 222           nullProvider = new StructureSelectionManager();
 223         }
 224         return nullProvider;
 225       }
 226     }
 227     if (instances == null)
 228     {
 229       instances = new java.util.IdentityHashMap<StructureSelectionManagerProvider, StructureSelectionManager>();
 230     }
 231     StructureSelectionManager instance = instances.get(context);
 232     if (instance == null)
 233     {
 234       if (nullProvider != null)
 235       {
 236         instance = nullProvider;
 237       }
 238       else
 239       {
 240         instance = new StructureSelectionManager();
 241       }
 242       instances.put(context, instance);
 243     }
 244     return instance;
 245   }
 246
 247   /**
 248    * flag controlling whether SeqMappings are relayed from received sequence
 249    * mouse over events to other sequences
 250    */
 251   boolean relaySeqMappings = true;
 252
 253   /**
 254    * Enable or disable relay of seqMapping events to other sequences. You might
 255    * want to do this if there are many sequence mappings and the host computer
 256    * is slow
 257    *
 258    * @param relay
 259    */
 260   public void setRelaySeqMappings(boolean relay)
 261   {
 262     relaySeqMappings = relay;
 263   }
 264
 265   /**
 266    * get the state of the relay seqMappings flag.
 267    *
 268    * @return true if sequence mouse overs are being relayed to other mapped
 269    *         sequences
 270    */
 271   public boolean isRelaySeqMappingsEnabled()
 272   {
 273     return relaySeqMappings;
 274   }
 275
 276   Vector listeners = new Vector();
 277
 278   /**
 279    * register a listener for alignment sequence mouseover events
 280    *
 281    * @param svl
 282    */
 283   public void addStructureViewerListener(Object svl)
 284   {
 285     if (!listeners.contains(svl))
 286     {
 287       listeners.addElement(svl);
 288     }
 289   }
 290
 291   /**
 292    * Returns the file name for a mapped PDB id (or null if not mapped).
 293    *
 294    * @param pdbid
 295    * @return
 296    */
 297   public String alreadyMappedToFile(String pdbid)
 298   {
 299     for (StructureMapping sm : mappings)
 300     {
 301       if (sm.getPdbId().equals(pdbid))
 302       {
 303         return sm.pdbfile;
 304       }
 305     }
 306     return null;
 307   }
 308
 309   /**
 310    * Import structure data and register a structure mapping for broadcasting
 311    * colouring, mouseovers and selection events (convenience wrapper).
 312    *
 313    * @param sequence
 314    *          - one or more sequences to be mapped to pdbFile
 315    * @param targetChains
 316    *          - optional chain specification for mapping each sequence to pdb
 317    *          (may be nill, individual elements may be nill)
 318    * @param pdbFile
 319    *          - structure data resource
 320    * @param protocol
 321    *          - how to resolve data from resource
 322    * @return null or the structure data parsed as a pdb file
 323    */
 324   synchronized public PDBfile setMapping(SequenceI[] sequence,
 325           String[] targetChains, String pdbFile, String protocol)
 326   {
 327     return setMapping(true, sequence, targetChains, pdbFile, protocol);
 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 sequence
 338    *          - one or more sequences to be mapped to pdbFile
 339    * @param targetChains
 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 PDBfile setMapping(boolean forStructureView,
 349           SequenceI[] sequence, String[] targetChains, String pdbFile,
 350           String protocol)
 351   {
 352     /*
 353      * There will be better ways of doing this in the future, for now we'll use
 354      * the tried and tested MCview pdb mapping
 355      */
 356     boolean parseSecStr = processSecondaryStructure;
 357     if (isPDBFileRegistered(pdbFile))
 358     {
 359       for (SequenceI sq : sequence)
 360       {
 361         SequenceI ds = sq;
 362         while (ds.getDatasetSequence() != null)
 363         {
 364           ds = ds.getDatasetSequence();
 365         }
 366         ;
 367         if (ds.getAnnotation() != null)
 368         {
 369           for (AlignmentAnnotation ala : ds.getAnnotation())
 370           {
 371             // false if any annotation present from this structure
 372             // JBPNote this fails for jmol/chimera view because the *file* is
 373             // passed, not the structure data ID -
 374             if (PDBfile.isCalcIdForFile(ala, findIdForPDBFile(pdbFile)))
 375             {
 376               parseSecStr = false;
 377             }
 378           }
 379         }
 380       }
 381     }
 382     PDBfile pdb = null;
 383     try
 384     {
 385       pdb = new PDBfile(addTempFacAnnot, parseSecStr, secStructServices,
 386               pdbFile, protocol);
 387       if (pdb.id != null && pdb.id.trim().length() > 0
 388               && AppletFormatAdapter.FILE.equals(protocol))
 389       {
 390         registerPDBFile(pdb.id.trim(), pdbFile);
 391       }
 392     } catch (Exception ex)
 393     {
 394       ex.printStackTrace();
 395       return null;
 396     }
 397
 398     String targetChain;
 399     for (int s = 0; s < sequence.length; s++)
 400     {
 401       boolean infChain = true;
 402       final SequenceI seq = sequence[s];
 403       if (targetChains != null && targetChains[s] != null)
 404       {
 405         infChain = false;
 406         targetChain = targetChains[s];
 407       }
 408       else if (seq.getName().indexOf("|") > -1)
 409       {
 410         targetChain = seq.getName().substring(
 411                 seq.getName().lastIndexOf("|") + 1);
 412         if (targetChain.length() > 1)
 413         {
 414           if (targetChain.trim().length() == 0)
 415           {
 416             targetChain = " ";
 417           }
 418           else
 419           {
 420             // not a valid chain identifier
 421             targetChain = "";
 422           }
 423         }
 424       }
 425       else
 426       {
 427         targetChain = "";
 428       }
 429
 430       /*
 431        * Attempt pairwise alignment of the sequence with each chain in the PDB,
 432        * and remember the highest scoring chain
 433        */
 434       int max = -10;
 435       AlignSeq maxAlignseq = null;
 436       String maxChainId = " ";
 437       PDBChain maxChain = null;
 438       boolean first = true;
 439       for (PDBChain chain : pdb.chains)
 440       {
 441         if (targetChain.length() > 0 && !targetChain.equals(chain.id)
 442                 && !infChain)
 443         {
 444           continue; // don't try to map chains don't match.
 445         }
 446         // TODO: correctly determine sequence type for mixed na/peptide
 447         // structures
 448         final String type = chain.isNa ? AlignSeq.DNA : AlignSeq.PEP;
 449         AlignSeq as = AlignSeq.doGlobalNWAlignment(seq, chain.sequence,
 450                 type);
 451         // equivalent to:
 452         // AlignSeq as = new AlignSeq(sequence[s], chain.sequence, type);
 453         // as.calcScoreMatrix();
 454         // as.traceAlignment();
 455
 456         if (first || as.maxscore > max
 457                 || (as.maxscore == max && chain.id.equals(targetChain)))
 458         {
 459           first = false;
 460           maxChain = chain;
 461           max = as.maxscore;
 462           maxAlignseq = as;
 463           maxChainId = chain.id;
 464         }
 465       }
 466       if (maxChain == null)
 467       {
 468         continue;
 469       }
 470       final StringBuilder mappingDetails = new StringBuilder(128);
 471       mappingDetails.append(NEWLINE).append("PDB Sequence is :")
 472               .append(NEWLINE).append("Sequence = ")
 473               .append(maxChain.sequence.getSequenceAsString());
 474       mappingDetails.append(NEWLINE).append("No of residues = ")
 475               .append(maxChain.residues.size()).append(NEWLINE)
 476               .append(NEWLINE);
 477       PrintStream ps = new PrintStream(System.out)
 478       {
 479         @Override
 480         public void print(String x)
 481         {
 482           mappingDetails.append(x);
 483         }
 484
 485         @Override
 486         public void println()
 487         {
 488           mappingDetails.append(NEWLINE);
 489         }
 490       };
 491
 492       maxAlignseq.printAlignment(ps);
 493
 494       mappingDetails.append(NEWLINE).append("PDB start/end ");
 495       mappingDetails.append(String.valueOf(maxAlignseq.seq2start)).append(
 496               " ");
 497       mappingDetails.append(String.valueOf(maxAlignseq.seq2end));
 498
 499       mappingDetails.append(NEWLINE).append("SEQ start/end ");
 500       mappingDetails.append(
 501               String.valueOf(maxAlignseq.seq1start + seq.getStart() - 1))
 502               .append(" ");
 503       mappingDetails.append(String.valueOf(maxAlignseq.seq1end
 504               + seq.getEnd() - 1));
 505
 506       maxChain.makeExactMapping(maxAlignseq, seq);
 507       Mapping sqmpping = maxAlignseq.getMappingFromS1(false);
 508       Mapping omap = new Mapping(sqmpping.getMap().getInverse());
 509       maxChain.transferRESNUMFeatures(seq, null);
 510
 511       // allocate enough slots to store the mapping from positions in
 512       // sequence[s] to the associated chain
 513       int[][] mapping = new int[seq.findPosition(seq.getLength()) + 2][2];
 514       int resNum = -10000;
 515       int index = 0;
 516
 517       do
 518       {
 519         Atom tmp = maxChain.atoms.elementAt(index);
 520         if (resNum != tmp.resNumber && tmp.alignmentMapping != -1)
 521         {
 522           resNum = tmp.resNumber;
 523           mapping[tmp.alignmentMapping + 1][0] = tmp.resNumber;
 524           mapping[tmp.alignmentMapping + 1][1] = tmp.atomIndex;
 525         }
 526
 527         index++;
 528       } while (index < maxChain.atoms.size());
 529
 530       if (protocol.equals(AppletFormatAdapter.PASTE))
 531       {
 532         pdbFile = "INLINE" + pdb.id;
 533       }
 534       StructureMapping newMapping = new StructureMapping(seq, pdbFile,
 535               pdb.id, maxChainId, mapping, mappingDetails.toString());
 536       if (forStructureView)
 537       {
 538         mappings.add(newMapping);
 539       }
 540       maxChain.transferResidueAnnotation(newMapping, sqmpping);
 541     }
 542     // ///////
 543
 544     return pdb;
 545   }
 546
 547   public void removeStructureViewerListener(Object svl, String[] pdbfiles)
 548   {
 549     listeners.removeElement(svl);
 550     if (svl instanceof SequenceListener)
 551     {
 552       for (int i = 0; i < listeners.size(); i++)
 553       {
 554         if (listeners.elementAt(i) instanceof StructureListener)
 555         {
 556           ((StructureListener) listeners.elementAt(i))
 557                   .releaseReferences(svl);
 558         }
 559       }
 560     }
 561
 562     if (pdbfiles == null)
 563     {
 564       return;
 565     }
 566
 567     /*
 568      * Remove mappings to the closed listener's PDB files, but first check if
 569      * another listener is still interested
 570      */
 571     List<String> pdbs = new ArrayList<String>(Arrays.asList(pdbfiles));
 572
 573     StructureListener sl;
 574     for (int i = 0; i < listeners.size(); i++)
 575     {
 576       if (listeners.elementAt(i) instanceof StructureListener)
 577       {
 578         sl = (StructureListener) listeners.elementAt(i);
 579         for (String pdbfile : sl.getPdbFile())
 580         {
 581           pdbs.remove(pdbfile);
 582         }
 583       }
 584     }
 585
 586     /*
 587      * Rebuild the mappings set, retaining only those which are for 'other' PDB
 588      * files
 589      */
 590     if (pdbs.size() > 0)
 591     {
 592       List<StructureMapping> tmp = new ArrayList<StructureMapping>();
 593       for (StructureMapping sm : mappings)
 594       {
 595         if (!pdbs.contains(sm.pdbfile))
 596         {
 597           tmp.add(sm);
 598         }
 599       }
 600
 601       mappings = tmp;
 602     }
 603   }
 604
 605   /**
 606    * Propagate mouseover of a single position in a structure
 607    *
 608    * @param pdbResNum
 609    * @param chain
 610    * @param pdbfile
 611    */
 612   public void mouseOverStructure(int pdbResNum, String chain, String pdbfile)
 613   {
 614     AtomSpec atomSpec = new AtomSpec(pdbfile, chain, pdbResNum, 0);
 615     List<AtomSpec> atoms = Collections.singletonList(atomSpec);
 616     mouseOverStructure(atoms);
 617   }
 618
 619   /**
 620    * Propagate mouseover or selection of multiple positions in a structure
 621    *
 622    * @param atoms
 623    */
 624   public void mouseOverStructure(List<AtomSpec> atoms)
 625   {
 626     if (listeners == null)
 627     {
 628       // old or prematurely sent event
 629       return;
 630     }
 631     boolean hasSequenceListener = false;
 632     for (int i = 0; i < listeners.size(); i++)
 633     {
 634       if (listeners.elementAt(i) instanceof SequenceListener)
 635       {
 636         hasSequenceListener = true;
 637       }
 638     }
 639     if (!hasSequenceListener)
 640     {
 641       return;
 642     }
 643
 644     SearchResults results = new SearchResults();
 645     for (AtomSpec atom : atoms)
 646     {
 647       SequenceI lastseq = null;
 648       int lastipos = -1;
 649       for (StructureMapping sm : mappings)
 650       {
 651         if (sm.pdbfile.equals(atom.getPdbFile())
 652                 && sm.pdbchain.equals(atom.getChain()))
 653         {
 654           int indexpos = sm.getSeqPos(atom.getPdbResNum());
 655           if (lastipos != indexpos && lastseq != sm.sequence)
 656           {
 657             results.addResult(sm.sequence, indexpos, indexpos);
 658             lastipos = indexpos;
 659             lastseq = sm.sequence;
 660             // construct highlighted sequence list
 661             for (AlignedCodonFrame acf : seqmappings)
 662             {
 663               acf.markMappedRegion(sm.sequence, indexpos, results);
 664             }
 665           }
 666         }
 667       }
 668     }
 669     for (Object li : listeners)
 670     {
 671       if (li instanceof SequenceListener)
 672       {
 673         ((SequenceListener) li).highlightSequence(results);
 674       }
 675     }
 676   }
 677
 678   /**
 679    * highlight regions associated with a position (indexpos) in seq
 680    *
 681    * @param seq
 682    *          the sequence that the mouse over occurred on
 683    * @param indexpos
 684    *          the absolute position being mouseovered in seq (0 to seq.length())
 685    * @param index
 686    *          the sequence position (if -1, seq.findPosition is called to
 687    *          resolve the residue number)
 688    */
 689   public void mouseOverSequence(SequenceI seq, int indexpos, int index,
 690           VamsasSource source)
 691   {
 692     boolean hasSequenceListeners = handlingVamsasMo
 693             || !seqmappings.isEmpty();
 694     SearchResults results = null;
 695     if (index == -1)
 696     {
 697       index = seq.findPosition(indexpos);
 698     }
 699     for (int i = 0; i < listeners.size(); i++)
 700     {
 701       Object listener = listeners.elementAt(i);
 702       if (listener == source)
 703       {
 704         // TODO listener (e.g. SeqPanel) is never == source (AlignViewport)
 705         // Temporary fudge with SequenceListener.getVamsasSource()
 706         continue;
 707       }
 708       if (listener instanceof StructureListener)
 709       {
 710         highlightStructure((StructureListener) listener, seq, index);
 711       }
 712       else
 713       {
 714         if (listener instanceof SequenceListener)
 715         {
 716           final SequenceListener seqListener = (SequenceListener) listener;
 717           if (hasSequenceListeners
 718                   && seqListener.getVamsasSource() != source)
 719           {
 720             if (relaySeqMappings)
 721             {
 722               if (results == null)
 723               {
 724                 results = MappingUtils.buildSearchResults(seq, index,
 725                         seqmappings);
 726               }
 727               if (handlingVamsasMo)
 728               {
 729                 results.addResult(seq, index, index);
 730
 731               }
 732               seqListener.highlightSequence(results);
 733             }
 734           }
 735         }
 736         else if (listener instanceof VamsasListener && !handlingVamsasMo)
 737         {
 738           ((VamsasListener) listener).mouseOverSequence(seq, indexpos,
 739                   source);
 740         }
 741         else if (listener instanceof SecondaryStructureListener)
 742         {
 743           ((SecondaryStructureListener) listener).mouseOverSequence(seq,
 744                   indexpos, index);
 745         }
 746       }
 747     }
 748   }
 749
 750   /**
 751    * Send suitable messages to a StructureListener to highlight atoms
 752    * corresponding to the given sequence position.
 753    *
 754    * @param sl
 755    * @param seq
 756    * @param index
 757    */
 758   protected void highlightStructure(StructureListener sl, SequenceI seq,
 759           int index)
 760   {
 761     if (!sl.isListeningFor(seq))
 762     {
 763       return;
 764     }
 765     int atomNo;
 766     List<AtomSpec> atoms = new ArrayList<AtomSpec>();
 767     for (StructureMapping sm : mappings)
 768     {
 769       if (sm.sequence == seq || sm.sequence == seq.getDatasetSequence())
 770       {
 771         atomNo = sm.getAtomNum(index);
 772
 773         if (atomNo > 0)
 774         {
 775           atoms.add(new AtomSpec(sm.pdbfile, sm.pdbchain, sm
 776                   .getPDBResNum(index), atomNo));
 777         }
 778       }
 779     }
 780     sl.highlightAtoms(atoms);
 781   }
 782
 783   /**
 784    * true if a mouse over event from an external (ie Vamsas) source is being
 785    * handled
 786    */
 787   boolean handlingVamsasMo = false;
 788
 789   long lastmsg = 0;
 790
 791   /**
 792    * as mouseOverSequence but only route event to SequenceListeners
 793    *
 794    * @param sequenceI
 795    * @param position
 796    *          in an alignment sequence
 797    */
 798   public void mouseOverVamsasSequence(SequenceI sequenceI, int position,
 799           VamsasSource source)
 800   {
 801     handlingVamsasMo = true;
 802     long msg = sequenceI.hashCode() * (1 + position);
 803     if (lastmsg != msg)
 804     {
 805       lastmsg = msg;
 806       mouseOverSequence(sequenceI, position, -1, source);
 807     }
 808     handlingVamsasMo = false;
 809   }
 810
 811   public Annotation[] colourSequenceFromStructure(SequenceI seq,
 812           String pdbid)
 813   {
 814     return null;
 815     // THIS WILL NOT BE AVAILABLE IN JALVIEW 2.3,
 816     // UNTIL THE COLOUR BY ANNOTATION IS REWORKED
 817     /*
 818      * Annotation [] annotations = new Annotation[seq.getLength()];
 819      *
 820      * StructureListener sl; int atomNo = 0; for (int i = 0; i <
 821      * listeners.size(); i++) { if (listeners.elementAt(i) instanceof
 822      * StructureListener) { sl = (StructureListener) listeners.elementAt(i);
 823      *
 824      * for (int j = 0; j < mappings.length; j++) {
 825      *
 826      * if (mappings[j].sequence == seq && mappings[j].getPdbId().equals(pdbid)
 827      * && mappings[j].pdbfile.equals(sl.getPdbFile())) {
 828      * System.out.println(pdbid+" "+mappings[j].getPdbId() +"
 829      * "+mappings[j].pdbfile);
 830      *
 831      * java.awt.Color col; for(int index=0; index<seq.getLength(); index++) {
 832      * if(Comparison.isGap(seq.getCharAt(index))) continue;
 833      *
 834      * atomNo = mappings[j].getAtomNum(seq.findPosition(index)); col =
 835      * java.awt.Color.white; if (atomNo > 0) { col = sl.getColour(atomNo,
 836      * mappings[j].getPDBResNum(index), mappings[j].pdbchain,
 837      * mappings[j].pdbfile); }
 838      *
 839      * annotations[index] = new Annotation("X",null,' ',0,col); } return
 840      * annotations; } } } }
 841      *
 842      * return annotations;
 843      */
 844   }
 845
 846   public void structureSelectionChanged()
 847   {
 848   }
 849
 850   public void sequenceSelectionChanged()
 851   {
 852   }
 853
 854   public void sequenceColoursChanged(Object source)
 855   {
 856     StructureListener sl;
 857     for (int i = 0; i < listeners.size(); i++)
 858     {
 859       if (listeners.elementAt(i) instanceof StructureListener)
 860       {
 861         sl = (StructureListener) listeners.elementAt(i);
 862         sl.updateColours(source);
 863       }
 864     }
 865   }
 866
 867   public StructureMapping[] getMapping(String pdbfile)
 868   {
 869     List<StructureMapping> tmp = new ArrayList<StructureMapping>();
 870     for (StructureMapping sm : mappings)
 871     {
 872       if (sm.pdbfile.equals(pdbfile))
 873       {
 874         tmp.add(sm);
 875       }
 876     }
 877     return tmp.toArray(new StructureMapping[tmp.size()]);
 878   }
 879
 880   /**
 881    * Returns a readable description of all mappings for the given pdbfile to any
 882    * of the given sequences
 883    *
 884    * @param pdbfile
 885    * @param seqs
 886    * @return
 887    */
 888   public String printMappings(String pdbfile, List<SequenceI> seqs)
 889   {
 890     if (pdbfile == null || seqs == null || seqs.isEmpty())
 891     {
 892       return "";
 893     }
 894
 895     StringBuilder sb = new StringBuilder(64);
 896     for (StructureMapping sm : mappings)
 897     {
 898       if (sm.pdbfile.equals(pdbfile) && seqs.contains(sm.sequence))
 899       {
 900         sb.append(sm.mappingDetails);
 901         sb.append(NEWLINE);
 902         // separator makes it easier to read multiple mappings
 903         sb.append("=====================");
 904         sb.append(NEWLINE);
 905       }
 906     }
 907     sb.append(NEWLINE);
 908
 909     return sb.toString();
 910   }
 911
 912   /**
 913    * Decrement the reference counter for each of the given mappings, and remove
 914    * it entirely if its reference counter reduces to zero.
 915    *
 916    * @param set
 917    */
 918   public void removeMappings(Set<AlignedCodonFrame> set)
 919   {
 920     if (set != null)
 921     {
 922       for (AlignedCodonFrame acf : set)
 923       {
 924         removeMapping(acf);
 925       }
 926     }
 927   }
 928
 929   /**
 930    * Decrement the reference counter for the given mapping, and remove it
 931    * entirely if its reference counter reduces to zero.
 932    *
 933    * @param acf
 934    */
 935   public void removeMapping(AlignedCodonFrame acf)
 936   {
 937     if (acf != null && seqmappings.contains(acf))
 938     {
 939       int count = seqMappingRefCounts.get(acf);
 940       count--;
 941       if (count > 0)
 942       {
 943         seqMappingRefCounts.put(acf, count);
 944       }
 945       else
 946       {
 947         seqmappings.remove(acf);
 948         seqMappingRefCounts.remove(acf);
 949       }
 950     }
 951   }
 952
 953   /**
 954    * Add each of the given codonFrames to the stored set. If not aready present,
 955    * increments its reference count instead.
 956    *
 957    * @param set
 958    */
 959   public void addMappings(Set<AlignedCodonFrame> set)
 960   {
 961     if (set != null)
 962     {
 963       for (AlignedCodonFrame acf : set)
 964       {
 965         addMapping(acf);
 966       }
 967     }
 968   }
 969
 970   /**
 971    * Add the given mapping to the stored set, or if already stored, increment
 972    * its reference counter.
 973    */
 974   public void addMapping(AlignedCodonFrame acf)
 975   {
 976     if (acf != null)
 977     {
 978       if (seqmappings.contains(acf))
 979       {
 980         seqMappingRefCounts.put(acf, seqMappingRefCounts.get(acf) + 1);
 981       }
 982       else
 983       {
 984         seqmappings.add(acf);
 985         seqMappingRefCounts.put(acf, 1);
 986       }
 987     }
 988   }
 989
 990   public void addSelectionListener(SelectionListener selecter)
 991   {
 992     if (!sel_listeners.contains(selecter))
 993     {
 994       sel_listeners.add(selecter);
 995     }
 996   }
 997
 998   public void removeSelectionListener(SelectionListener toremove)
 999   {
1000     if (sel_listeners.contains(toremove))
1001     {
1002       sel_listeners.remove(toremove);
1003     }
1004   }
1005
1006   public synchronized void sendSelection(SequenceGroup selection,
1007           ColumnSelection colsel, SelectionSource source)
1008   {
1009     for (SelectionListener slis : sel_listeners)
1010     {
1011       if (slis != source)
1012       {
1013         slis.selection(selection, colsel, source);
1014       }
1015     }
1016   }
1017
1018   Vector<AlignmentViewPanelListener> view_listeners = new Vector<AlignmentViewPanelListener>();
1019
1020   public synchronized void sendViewPosition(
1021 AlignmentViewPanel source,
1022           int startRes, int endRes,
1023           int startSeq, int endSeq)
1024   {
1025
1026     if (view_listeners != null && view_listeners.size() > 0)
1027     {
1028       Enumeration<AlignmentViewPanelListener> listeners = view_listeners
1029               .elements();
1030       while (listeners.hasMoreElements())
1031       {
1032         AlignmentViewPanelListener slis = listeners.nextElement();
1033         if (slis != source)
1034         {
1035           slis.viewPosition(startRes, endRes, startSeq, endSeq, source);
1036         }
1037         ;
1038       }
1039     }
1040   }
1041
1042   /**
1043    * release all references associated with this manager provider
1044    *
1045    * @param jalviewLite
1046    */
1047   public static void release(StructureSelectionManagerProvider jalviewLite)
1048   {
1049     // synchronized (instances)
1050     {
1051       if (instances == null)
1052       {
1053         return;
1054       }
1055       StructureSelectionManager mnger = (instances.get(jalviewLite));
1056       if (mnger != null)
1057       {
1058         instances.remove(jalviewLite);
1059         try
1060         {
1061           mnger.finalize();
1062         } catch (Throwable x)
1063         {
1064         }
1065       }
1066     }
1067   }
1068
1069   public void registerPDBEntry(PDBEntry pdbentry)
1070   {
1071     if (pdbentry.getFile() != null
1072             && pdbentry.getFile().trim().length() > 0)
1073     {
1074       registerPDBFile(pdbentry.getId(), pdbentry.getFile());
1075     }
1076   }
1077
1078   public void addCommandListener(CommandListener cl)
1079   {
1080     if (!commandListeners.contains(cl))
1081     {
1082       commandListeners.add(cl);
1083     }
1084   }
1085
1086   public boolean hasCommandListener(CommandListener cl)
1087   {
1088     return this.commandListeners.contains(cl);
1089   }
1090
1091   public boolean removeCommandListener(CommandListener l)
1092   {
1093     return commandListeners.remove(l);
1094   }
1095
1096   /**
1097    * Forward a command to any command listeners (except for the command's
1098    * source).
1099    *
1100    * @param command
1101    *          the command to be broadcast (in its form after being performed)
1102    * @param undo
1103    *          if true, the command was being 'undone'
1104    * @param source
1105    */
1106   public void commandPerformed(CommandI command, boolean undo,
1107           VamsasSource source)
1108   {
1109     for (CommandListener listener : commandListeners)
1110     {
1111       listener.mirrorCommand(command, undo, this, source);
1112     }
1113   }
1114
1115   /**
1116    * Returns a new CommandI representing the given command as mapped to the
1117    * given sequences. If no mapping could be made, or the command is not of a
1118    * mappable kind, returns null.
1119    *
1120    * @param command
1121    * @param undo
1122    * @param mapTo
1123    * @param gapChar
1124    * @return
1125    */
1126   public CommandI mapCommand(CommandI command, boolean undo,
1127           final AlignmentI mapTo, char gapChar)
1128   {
1129     if (command instanceof EditCommand)
1130     {
1131       return MappingUtils.mapEditCommand((EditCommand) command, undo,
1132               mapTo, gapChar, seqmappings);
1133     }
1134     else if (command instanceof OrderCommand)
1135     {
1136       return MappingUtils.mapOrderCommand((OrderCommand) command, undo,
1137               mapTo, seqmappings);
1138     }
1139     return null;
1140   }
1141 }